?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mic: vop: Fix use-after-free on remove
[linux/fpc-iii.git] / drivers / scsi / mpt3sas / mpt3sas_transport.c
blob60ae2d0feb2be84b27a1d17bd730dabe94cfd925
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 mpt3sas_base_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 if ((ioc->logging_level & MPT_DEBUG_TRANSPORT))
723 dev_printk(KERN_INFO, &rphy->dev,
724 "add: handle(0x%04x), sas_addr(0x%016llx)\n",
725 handle, (unsigned long long)
726 mpt3sas_port->remote_identify.sas_address);
727 mpt3sas_port->rphy = rphy;
728 spin_lock_irqsave(&ioc->sas_node_lock, flags);
729 list_add_tail(&mpt3sas_port->port_list, &sas_node->sas_port_list);
730 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
731
732 /* fill in report manufacture */
733 if (mpt3sas_port->remote_identify.device_type ==
734 MPI2_SAS_DEVICE_INFO_EDGE_EXPANDER ||
735 mpt3sas_port->remote_identify.device_type ==
736 MPI2_SAS_DEVICE_INFO_FANOUT_EXPANDER)
737 _transport_expander_report_manufacture(ioc,
738 mpt3sas_port->remote_identify.sas_address,
739 rphy_to_expander_device(rphy));
740 return mpt3sas_port;
741
742 out_fail:
743 list_for_each_entry_safe(mpt3sas_phy, next, &mpt3sas_port->phy_list,
744 port_siblings)
745 list_del(&mpt3sas_phy->port_siblings);
746 kfree(mpt3sas_port);
747 return NULL;
748 }
749
750 /**
751 * mpt3sas_transport_port_remove - remove port from the list
752 * @ioc: per adapter object
753 * @sas_address: sas address of attached device
754 * @sas_address_parent: sas address of parent expander or sas host
755 * Context: This function will acquire ioc->sas_node_lock.
756 *
757 * Removing object and freeing associated memory from the
758 * ioc->sas_port_list.
759 */
760 void
761 mpt3sas_transport_port_remove(struct MPT3SAS_ADAPTER *ioc, u64 sas_address,
762 u64 sas_address_parent)
763 {
764 int i;
765 unsigned long flags;
766 struct _sas_port *mpt3sas_port, *next;
767 struct _sas_node *sas_node;
768 u8 found = 0;
769 struct _sas_phy *mpt3sas_phy, *next_phy;
770
771 spin_lock_irqsave(&ioc->sas_node_lock, flags);
772 sas_node = _transport_sas_node_find_by_sas_address(ioc,
773 sas_address_parent);
774 if (!sas_node) {
775 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
776 return;
777 }
778 list_for_each_entry_safe(mpt3sas_port, next, &sas_node->sas_port_list,
779 port_list) {
780 if (mpt3sas_port->remote_identify.sas_address != sas_address)
781 continue;
782 found = 1;
783 list_del(&mpt3sas_port->port_list);
784 goto out;
785 }
786 out:
787 if (!found) {
788 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
789 return;
790 }
791
792 for (i = 0; i < sas_node->num_phys; i++) {
793 if (sas_node->phy[i].remote_identify.sas_address == sas_address)
794 memset(&sas_node->phy[i].remote_identify, 0 ,
795 sizeof(struct sas_identify));
796 }
797
798 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
799
800 list_for_each_entry_safe(mpt3sas_phy, next_phy,
801 &mpt3sas_port->phy_list, port_siblings) {
802 if ((ioc->logging_level & MPT_DEBUG_TRANSPORT))
803 dev_printk(KERN_INFO, &mpt3sas_port->port->dev,
804 "remove: sas_addr(0x%016llx), phy(%d)\n",
805 (unsigned long long)
806 mpt3sas_port->remote_identify.sas_address,
807 mpt3sas_phy->phy_id);
808 mpt3sas_phy->phy_belongs_to_port = 0;
809 if (!ioc->remove_host)
810 sas_port_delete_phy(mpt3sas_port->port,
811 mpt3sas_phy->phy);
812 list_del(&mpt3sas_phy->port_siblings);
813 }
814 if (!ioc->remove_host)
815 sas_port_delete(mpt3sas_port->port);
816 kfree(mpt3sas_port);
817 }
818
819 /**
820 * mpt3sas_transport_add_host_phy - report sas_host phy to transport
821 * @ioc: per adapter object
822 * @mpt3sas_phy: mpt3sas per phy object
823 * @phy_pg0: sas phy page 0
824 * @parent_dev: parent device class object
825 *
826 * Return: 0 for success, non-zero for failure.
827 */
828 int
829 mpt3sas_transport_add_host_phy(struct MPT3SAS_ADAPTER *ioc, struct _sas_phy
830 *mpt3sas_phy, Mpi2SasPhyPage0_t phy_pg0, struct device *parent_dev)
831 {
832 struct sas_phy *phy;
833 int phy_index = mpt3sas_phy->phy_id;
834
835
836 INIT_LIST_HEAD(&mpt3sas_phy->port_siblings);
837 phy = sas_phy_alloc(parent_dev, phy_index);
838 if (!phy) {
839 ioc_err(ioc, "failure at %s:%d/%s()!\n",
840 __FILE__, __LINE__, __func__);
841 return -1;
842 }
843 if ((_transport_set_identify(ioc, mpt3sas_phy->handle,
844 &mpt3sas_phy->identify))) {
845 ioc_err(ioc, "failure at %s:%d/%s()!\n",
846 __FILE__, __LINE__, __func__);
847 sas_phy_free(phy);
848 return -1;
849 }
850 phy->identify = mpt3sas_phy->identify;
851 mpt3sas_phy->attached_handle = le16_to_cpu(phy_pg0.AttachedDevHandle);
852 if (mpt3sas_phy->attached_handle)
853 _transport_set_identify(ioc, mpt3sas_phy->attached_handle,
854 &mpt3sas_phy->remote_identify);
855 phy->identify.phy_identifier = mpt3sas_phy->phy_id;
856 phy->negotiated_linkrate = _transport_convert_phy_link_rate(
857 phy_pg0.NegotiatedLinkRate & MPI2_SAS_NEG_LINK_RATE_MASK_PHYSICAL);
858 phy->minimum_linkrate_hw = _transport_convert_phy_link_rate(
859 phy_pg0.HwLinkRate & MPI2_SAS_HWRATE_MIN_RATE_MASK);
860 phy->maximum_linkrate_hw = _transport_convert_phy_link_rate(
861 phy_pg0.HwLinkRate >> 4);
862 phy->minimum_linkrate = _transport_convert_phy_link_rate(
863 phy_pg0.ProgrammedLinkRate & MPI2_SAS_PRATE_MIN_RATE_MASK);
864 phy->maximum_linkrate = _transport_convert_phy_link_rate(
865 phy_pg0.ProgrammedLinkRate >> 4);
866
867 if ((sas_phy_add(phy))) {
868 ioc_err(ioc, "failure at %s:%d/%s()!\n",
869 __FILE__, __LINE__, __func__);
870 sas_phy_free(phy);
871 return -1;
872 }
873 if ((ioc->logging_level & MPT_DEBUG_TRANSPORT))
874 dev_printk(KERN_INFO, &phy->dev,
875 "add: handle(0x%04x), sas_addr(0x%016llx)\n"
876 "\tattached_handle(0x%04x), sas_addr(0x%016llx)\n",
877 mpt3sas_phy->handle, (unsigned long long)
878 mpt3sas_phy->identify.sas_address,
879 mpt3sas_phy->attached_handle,
880 (unsigned long long)
881 mpt3sas_phy->remote_identify.sas_address);
882 mpt3sas_phy->phy = phy;
883 return 0;
884 }
885
886
887 /**
888 * mpt3sas_transport_add_expander_phy - report expander phy to transport
889 * @ioc: per adapter object
890 * @mpt3sas_phy: mpt3sas per phy object
891 * @expander_pg1: expander page 1
892 * @parent_dev: parent device class object
893 *
894 * Return: 0 for success, non-zero for failure.
895 */
896 int
897 mpt3sas_transport_add_expander_phy(struct MPT3SAS_ADAPTER *ioc, struct _sas_phy
898 *mpt3sas_phy, Mpi2ExpanderPage1_t expander_pg1,
899 struct device *parent_dev)
900 {
901 struct sas_phy *phy;
902 int phy_index = mpt3sas_phy->phy_id;
903
904 INIT_LIST_HEAD(&mpt3sas_phy->port_siblings);
905 phy = sas_phy_alloc(parent_dev, phy_index);
906 if (!phy) {
907 ioc_err(ioc, "failure at %s:%d/%s()!\n",
908 __FILE__, __LINE__, __func__);
909 return -1;
910 }
911 if ((_transport_set_identify(ioc, mpt3sas_phy->handle,
912 &mpt3sas_phy->identify))) {
913 ioc_err(ioc, "failure at %s:%d/%s()!\n",
914 __FILE__, __LINE__, __func__);
915 sas_phy_free(phy);
916 return -1;
917 }
918 phy->identify = mpt3sas_phy->identify;
919 mpt3sas_phy->attached_handle =
920 le16_to_cpu(expander_pg1.AttachedDevHandle);
921 if (mpt3sas_phy->attached_handle)
922 _transport_set_identify(ioc, mpt3sas_phy->attached_handle,
923 &mpt3sas_phy->remote_identify);
924 phy->identify.phy_identifier = mpt3sas_phy->phy_id;
925 phy->negotiated_linkrate = _transport_convert_phy_link_rate(
926 expander_pg1.NegotiatedLinkRate &
927 MPI2_SAS_NEG_LINK_RATE_MASK_PHYSICAL);
928 phy->minimum_linkrate_hw = _transport_convert_phy_link_rate(
929 expander_pg1.HwLinkRate & MPI2_SAS_HWRATE_MIN_RATE_MASK);
930 phy->maximum_linkrate_hw = _transport_convert_phy_link_rate(
931 expander_pg1.HwLinkRate >> 4);
932 phy->minimum_linkrate = _transport_convert_phy_link_rate(
933 expander_pg1.ProgrammedLinkRate & MPI2_SAS_PRATE_MIN_RATE_MASK);
934 phy->maximum_linkrate = _transport_convert_phy_link_rate(
935 expander_pg1.ProgrammedLinkRate >> 4);
936
937 if ((sas_phy_add(phy))) {
938 ioc_err(ioc, "failure at %s:%d/%s()!\n",
939 __FILE__, __LINE__, __func__);
940 sas_phy_free(phy);
941 return -1;
942 }
943 if ((ioc->logging_level & MPT_DEBUG_TRANSPORT))
944 dev_printk(KERN_INFO, &phy->dev,
945 "add: handle(0x%04x), sas_addr(0x%016llx)\n"
946 "\tattached_handle(0x%04x), sas_addr(0x%016llx)\n",
947 mpt3sas_phy->handle, (unsigned long long)
948 mpt3sas_phy->identify.sas_address,
949 mpt3sas_phy->attached_handle,
950 (unsigned long long)
951 mpt3sas_phy->remote_identify.sas_address);
952 mpt3sas_phy->phy = phy;
953 return 0;
954 }
955
956 /**
957 * mpt3sas_transport_update_links - refreshing phy link changes
958 * @ioc: per adapter object
959 * @sas_address: sas address of parent expander or sas host
960 * @handle: attached device handle
961 * @phy_number: phy number
962 * @link_rate: new link rate
963 */
964 void
965 mpt3sas_transport_update_links(struct MPT3SAS_ADAPTER *ioc,
966 u64 sas_address, u16 handle, u8 phy_number, u8 link_rate)
967 {
968 unsigned long flags;
969 struct _sas_node *sas_node;
970 struct _sas_phy *mpt3sas_phy;
971
972 if (ioc->shost_recovery || ioc->pci_error_recovery)
973 return;
974
975 spin_lock_irqsave(&ioc->sas_node_lock, flags);
976 sas_node = _transport_sas_node_find_by_sas_address(ioc, sas_address);
977 if (!sas_node) {
978 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
979 return;
980 }
981
982 mpt3sas_phy = &sas_node->phy[phy_number];
983 mpt3sas_phy->attached_handle = handle;
984 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
985 if (handle && (link_rate >= MPI2_SAS_NEG_LINK_RATE_1_5)) {
986 _transport_set_identify(ioc, handle,
987 &mpt3sas_phy->remote_identify);
988 _transport_add_phy_to_an_existing_port(ioc, sas_node,
989 mpt3sas_phy, mpt3sas_phy->remote_identify.sas_address);
990 } else
991 memset(&mpt3sas_phy->remote_identify, 0 , sizeof(struct
992 sas_identify));
993
994 if (mpt3sas_phy->phy)
995 mpt3sas_phy->phy->negotiated_linkrate =
996 _transport_convert_phy_link_rate(link_rate);
997
998 if ((ioc->logging_level & MPT_DEBUG_TRANSPORT))
999 dev_printk(KERN_INFO, &mpt3sas_phy->phy->dev,
1000 "refresh: parent sas_addr(0x%016llx),\n"
1001 "\tlink_rate(0x%02x), phy(%d)\n"
1002 "\tattached_handle(0x%04x), sas_addr(0x%016llx)\n",
1003 (unsigned long long)sas_address,
1004 link_rate, phy_number, handle, (unsigned long long)
1005 mpt3sas_phy->remote_identify.sas_address);
1006 }
1007
1008 static inline void *
1009 phy_to_ioc(struct sas_phy *phy)
1010 {
1011 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
1012 return shost_priv(shost);
1013 }
1014
1015 static inline void *
1016 rphy_to_ioc(struct sas_rphy *rphy)
1017 {
1018 struct Scsi_Host *shost = dev_to_shost(rphy->dev.parent->parent);
1019 return shost_priv(shost);
1020 }
1021
1022 /* report phy error log structure */
1023 struct phy_error_log_request {
1024 u8 smp_frame_type; /* 0x40 */
1025 u8 function; /* 0x11 */
1026 u8 allocated_response_length;
1027 u8 request_length; /* 02 */
1028 u8 reserved_1[5];
1029 u8 phy_identifier;
1030 u8 reserved_2[2];
1031 };
1032
1033 /* report phy error log reply structure */
1034 struct phy_error_log_reply {
1035 u8 smp_frame_type; /* 0x41 */
1036 u8 function; /* 0x11 */
1037 u8 function_result;
1038 u8 response_length;
1039 __be16 expander_change_count;
1040 u8 reserved_1[3];
1041 u8 phy_identifier;
1042 u8 reserved_2[2];
1043 __be32 invalid_dword;
1044 __be32 running_disparity_error;
1045 __be32 loss_of_dword_sync;
1046 __be32 phy_reset_problem;
1047 };
1048
1049 /**
1050 * _transport_get_expander_phy_error_log - return expander counters
1051 * @ioc: per adapter object
1052 * @phy: The sas phy object
1053 *
1054 * Return: 0 for success, non-zero for failure.
1055 *
1056 */
1057 static int
1058 _transport_get_expander_phy_error_log(struct MPT3SAS_ADAPTER *ioc,
1059 struct sas_phy *phy)
1060 {
1061 Mpi2SmpPassthroughRequest_t *mpi_request;
1062 Mpi2SmpPassthroughReply_t *mpi_reply;
1063 struct phy_error_log_request *phy_error_log_request;
1064 struct phy_error_log_reply *phy_error_log_reply;
1065 int rc;
1066 u16 smid;
1067 void *psge;
1068 u8 issue_reset = 0;
1069 void *data_out = NULL;
1070 dma_addr_t data_out_dma;
1071 u32 sz;
1072
1073 if (ioc->shost_recovery || ioc->pci_error_recovery) {
1074 ioc_info(ioc, "%s: host reset in progress!\n", __func__);
1075 return -EFAULT;
1076 }
1077
1078 mutex_lock(&ioc->transport_cmds.mutex);
1079
1080 if (ioc->transport_cmds.status != MPT3_CMD_NOT_USED) {
1081 ioc_err(ioc, "%s: transport_cmds in use\n", __func__);
1082 rc = -EAGAIN;
1083 goto out;
1084 }
1085 ioc->transport_cmds.status = MPT3_CMD_PENDING;
1086
1087 rc = mpt3sas_wait_for_ioc(ioc, IOC_OPERATIONAL_WAIT_COUNT);
1088 if (rc)
1089 goto out;
1090
1091 smid = mpt3sas_base_get_smid(ioc, ioc->transport_cb_idx);
1092 if (!smid) {
1093 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
1094 rc = -EAGAIN;
1095 goto out;
1096 }
1097
1098 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
1099 ioc->transport_cmds.smid = smid;
1100
1101 sz = sizeof(struct phy_error_log_request) +
1102 sizeof(struct phy_error_log_reply);
1103 data_out = dma_alloc_coherent(&ioc->pdev->dev, sz, &data_out_dma,
1104 GFP_KERNEL);
1105 if (!data_out) {
1106 pr_err("failure at %s:%d/%s()!\n", __FILE__,
1107 __LINE__, __func__);
1108 rc = -ENOMEM;
1109 mpt3sas_base_free_smid(ioc, smid);
1110 goto out;
1111 }
1112
1113 rc = -EINVAL;
1114 memset(data_out, 0, sz);
1115 phy_error_log_request = data_out;
1116 phy_error_log_request->smp_frame_type = 0x40;
1117 phy_error_log_request->function = 0x11;
1118 phy_error_log_request->request_length = 2;
1119 phy_error_log_request->allocated_response_length = 0;
1120 phy_error_log_request->phy_identifier = phy->number;
1121
1122 memset(mpi_request, 0, sizeof(Mpi2SmpPassthroughRequest_t));
1123 mpi_request->Function = MPI2_FUNCTION_SMP_PASSTHROUGH;
1124 mpi_request->PhysicalPort = 0xFF;
1125 mpi_request->VF_ID = 0; /* TODO */
1126 mpi_request->VP_ID = 0;
1127 mpi_request->SASAddress = cpu_to_le64(phy->identify.sas_address);
1128 mpi_request->RequestDataLength =
1129 cpu_to_le16(sizeof(struct phy_error_log_request));
1130 psge = &mpi_request->SGL;
1131
1132 ioc->build_sg(ioc, psge, data_out_dma,
1133 sizeof(struct phy_error_log_request),
1134 data_out_dma + sizeof(struct phy_error_log_request),
1135 sizeof(struct phy_error_log_reply));
1136
1137 dtransportprintk(ioc,
1138 ioc_info(ioc, "phy_error_log - send to sas_addr(0x%016llx), phy(%d)\n",
1139 (u64)phy->identify.sas_address,
1140 phy->number));
1141 init_completion(&ioc->transport_cmds.done);
1142 mpt3sas_base_put_smid_default(ioc, smid);
1143 wait_for_completion_timeout(&ioc->transport_cmds.done, 10*HZ);
1144
1145 if (!(ioc->transport_cmds.status & MPT3_CMD_COMPLETE)) {
1146 ioc_err(ioc, "%s: timeout\n", __func__);
1147 _debug_dump_mf(mpi_request,
1148 sizeof(Mpi2SmpPassthroughRequest_t)/4);
1149 if (!(ioc->transport_cmds.status & MPT3_CMD_RESET))
1150 issue_reset = 1;
1151 goto issue_host_reset;
1152 }
1153
1154 dtransportprintk(ioc, ioc_info(ioc, "phy_error_log - complete\n"));
1155
1156 if (ioc->transport_cmds.status & MPT3_CMD_REPLY_VALID) {
1157
1158 mpi_reply = ioc->transport_cmds.reply;
1159
1160 dtransportprintk(ioc,
1161 ioc_info(ioc, "phy_error_log - reply data transfer size(%d)\n",
1162 le16_to_cpu(mpi_reply->ResponseDataLength)));
1163
1164 if (le16_to_cpu(mpi_reply->ResponseDataLength) !=
1165 sizeof(struct phy_error_log_reply))
1166 goto out;
1167
1168 phy_error_log_reply = data_out +
1169 sizeof(struct phy_error_log_request);
1170
1171 dtransportprintk(ioc,
1172 ioc_info(ioc, "phy_error_log - function_result(%d)\n",
1173 phy_error_log_reply->function_result));
1174
1175 phy->invalid_dword_count =
1176 be32_to_cpu(phy_error_log_reply->invalid_dword);
1177 phy->running_disparity_error_count =
1178 be32_to_cpu(phy_error_log_reply->running_disparity_error);
1179 phy->loss_of_dword_sync_count =
1180 be32_to_cpu(phy_error_log_reply->loss_of_dword_sync);
1181 phy->phy_reset_problem_count =
1182 be32_to_cpu(phy_error_log_reply->phy_reset_problem);
1183 rc = 0;
1184 } else
1185 dtransportprintk(ioc,
1186 ioc_info(ioc, "phy_error_log - no reply\n"));
1187
1188 issue_host_reset:
1189 if (issue_reset)
1190 mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
1191 out:
1192 ioc->transport_cmds.status = MPT3_CMD_NOT_USED;
1193 if (data_out)
1194 dma_free_coherent(&ioc->pdev->dev, sz, data_out, data_out_dma);
1195
1196 mutex_unlock(&ioc->transport_cmds.mutex);
1197 return rc;
1198 }
1199
1200 /**
1201 * _transport_get_linkerrors - return phy counters for both hba and expanders
1202 * @phy: The sas phy object
1203 *
1204 * Return: 0 for success, non-zero for failure.
1205 *
1206 */
1207 static int
1208 _transport_get_linkerrors(struct sas_phy *phy)
1209 {
1210 struct MPT3SAS_ADAPTER *ioc = phy_to_ioc(phy);
1211 unsigned long flags;
1212 Mpi2ConfigReply_t mpi_reply;
1213 Mpi2SasPhyPage1_t phy_pg1;
1214
1215 spin_lock_irqsave(&ioc->sas_node_lock, flags);
1216 if (_transport_sas_node_find_by_sas_address(ioc,
1217 phy->identify.sas_address) == NULL) {
1218 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1219 return -EINVAL;
1220 }
1221 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1222
1223 if (phy->identify.sas_address != ioc->sas_hba.sas_address)
1224 return _transport_get_expander_phy_error_log(ioc, phy);
1225
1226 /* get hba phy error logs */
1227 if ((mpt3sas_config_get_phy_pg1(ioc, &mpi_reply, &phy_pg1,
1228 phy->number))) {
1229 ioc_err(ioc, "failure at %s:%d/%s()!\n",
1230 __FILE__, __LINE__, __func__);
1231 return -ENXIO;
1232 }
1233
1234 if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo)
1235 ioc_info(ioc, "phy(%d), ioc_status (0x%04x), loginfo(0x%08x)\n",
1236 phy->number,
1237 le16_to_cpu(mpi_reply.IOCStatus),
1238 le32_to_cpu(mpi_reply.IOCLogInfo));
1239
1240 phy->invalid_dword_count = le32_to_cpu(phy_pg1.InvalidDwordCount);
1241 phy->running_disparity_error_count =
1242 le32_to_cpu(phy_pg1.RunningDisparityErrorCount);
1243 phy->loss_of_dword_sync_count =
1244 le32_to_cpu(phy_pg1.LossDwordSynchCount);
1245 phy->phy_reset_problem_count =
1246 le32_to_cpu(phy_pg1.PhyResetProblemCount);
1247 return 0;
1248 }
1249
1250 /**
1251 * _transport_get_enclosure_identifier -
1252 * @rphy: The sas phy object
1253 * @identifier: ?
1254 *
1255 * Obtain the enclosure logical id for an expander.
1256 * Return: 0 for success, non-zero for failure.
1257 */
1258 static int
1259 _transport_get_enclosure_identifier(struct sas_rphy *rphy, u64 *identifier)
1260 {
1261 struct MPT3SAS_ADAPTER *ioc = rphy_to_ioc(rphy);
1262 struct _sas_device *sas_device;
1263 unsigned long flags;
1264 int rc;
1265
1266 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1267 sas_device = __mpt3sas_get_sdev_by_addr(ioc,
1268 rphy->identify.sas_address);
1269 if (sas_device) {
1270 *identifier = sas_device->enclosure_logical_id;
1271 rc = 0;
1272 sas_device_put(sas_device);
1273 } else {
1274 *identifier = 0;
1275 rc = -ENXIO;
1276 }
1277
1278 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1279 return rc;
1280 }
1281
1282 /**
1283 * _transport_get_bay_identifier -
1284 * @rphy: The sas phy object
1285 *
1286 * Return: the slot id for a device that resides inside an enclosure.
1287 */
1288 static int
1289 _transport_get_bay_identifier(struct sas_rphy *rphy)
1290 {
1291 struct MPT3SAS_ADAPTER *ioc = rphy_to_ioc(rphy);
1292 struct _sas_device *sas_device;
1293 unsigned long flags;
1294 int rc;
1295
1296 spin_lock_irqsave(&ioc->sas_device_lock, flags);
1297 sas_device = __mpt3sas_get_sdev_by_addr(ioc,
1298 rphy->identify.sas_address);
1299 if (sas_device) {
1300 rc = sas_device->slot;
1301 sas_device_put(sas_device);
1302 } else {
1303 rc = -ENXIO;
1304 }
1305 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
1306 return rc;
1307 }
1308
1309 /* phy control request structure */
1310 struct phy_control_request {
1311 u8 smp_frame_type; /* 0x40 */
1312 u8 function; /* 0x91 */
1313 u8 allocated_response_length;
1314 u8 request_length; /* 0x09 */
1315 u16 expander_change_count;
1316 u8 reserved_1[3];
1317 u8 phy_identifier;
1318 u8 phy_operation;
1319 u8 reserved_2[13];
1320 u64 attached_device_name;
1321 u8 programmed_min_physical_link_rate;
1322 u8 programmed_max_physical_link_rate;
1323 u8 reserved_3[6];
1324 };
1325
1326 /* phy control reply structure */
1327 struct phy_control_reply {
1328 u8 smp_frame_type; /* 0x41 */
1329 u8 function; /* 0x11 */
1330 u8 function_result;
1331 u8 response_length;
1332 };
1333
1334 #define SMP_PHY_CONTROL_LINK_RESET (0x01)
1335 #define SMP_PHY_CONTROL_HARD_RESET (0x02)
1336 #define SMP_PHY_CONTROL_DISABLE (0x03)
1337
1338 /**
1339 * _transport_expander_phy_control - expander phy control
1340 * @ioc: per adapter object
1341 * @phy: The sas phy object
1342 * @phy_operation: ?
1343 *
1344 * Return: 0 for success, non-zero for failure.
1345 *
1346 */
1347 static int
1348 _transport_expander_phy_control(struct MPT3SAS_ADAPTER *ioc,
1349 struct sas_phy *phy, u8 phy_operation)
1350 {
1351 Mpi2SmpPassthroughRequest_t *mpi_request;
1352 Mpi2SmpPassthroughReply_t *mpi_reply;
1353 struct phy_control_request *phy_control_request;
1354 struct phy_control_reply *phy_control_reply;
1355 int rc;
1356 u16 smid;
1357 void *psge;
1358 u8 issue_reset = 0;
1359 void *data_out = NULL;
1360 dma_addr_t data_out_dma;
1361 u32 sz;
1362
1363 if (ioc->shost_recovery || ioc->pci_error_recovery) {
1364 ioc_info(ioc, "%s: host reset in progress!\n", __func__);
1365 return -EFAULT;
1366 }
1367
1368 mutex_lock(&ioc->transport_cmds.mutex);
1369
1370 if (ioc->transport_cmds.status != MPT3_CMD_NOT_USED) {
1371 ioc_err(ioc, "%s: transport_cmds in use\n", __func__);
1372 rc = -EAGAIN;
1373 goto out;
1374 }
1375 ioc->transport_cmds.status = MPT3_CMD_PENDING;
1376
1377 rc = mpt3sas_wait_for_ioc(ioc, IOC_OPERATIONAL_WAIT_COUNT);
1378 if (rc)
1379 goto out;
1380
1381 smid = mpt3sas_base_get_smid(ioc, ioc->transport_cb_idx);
1382 if (!smid) {
1383 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
1384 rc = -EAGAIN;
1385 goto out;
1386 }
1387
1388 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
1389 ioc->transport_cmds.smid = smid;
1390
1391 sz = sizeof(struct phy_control_request) +
1392 sizeof(struct phy_control_reply);
1393 data_out = dma_alloc_coherent(&ioc->pdev->dev, sz, &data_out_dma,
1394 GFP_KERNEL);
1395 if (!data_out) {
1396 pr_err("failure at %s:%d/%s()!\n", __FILE__,
1397 __LINE__, __func__);
1398 rc = -ENOMEM;
1399 mpt3sas_base_free_smid(ioc, smid);
1400 goto out;
1401 }
1402
1403 rc = -EINVAL;
1404 memset(data_out, 0, sz);
1405 phy_control_request = data_out;
1406 phy_control_request->smp_frame_type = 0x40;
1407 phy_control_request->function = 0x91;
1408 phy_control_request->request_length = 9;
1409 phy_control_request->allocated_response_length = 0;
1410 phy_control_request->phy_identifier = phy->number;
1411 phy_control_request->phy_operation = phy_operation;
1412 phy_control_request->programmed_min_physical_link_rate =
1413 phy->minimum_linkrate << 4;
1414 phy_control_request->programmed_max_physical_link_rate =
1415 phy->maximum_linkrate << 4;
1416
1417 memset(mpi_request, 0, sizeof(Mpi2SmpPassthroughRequest_t));
1418 mpi_request->Function = MPI2_FUNCTION_SMP_PASSTHROUGH;
1419 mpi_request->PhysicalPort = 0xFF;
1420 mpi_request->VF_ID = 0; /* TODO */
1421 mpi_request->VP_ID = 0;
1422 mpi_request->SASAddress = cpu_to_le64(phy->identify.sas_address);
1423 mpi_request->RequestDataLength =
1424 cpu_to_le16(sizeof(struct phy_error_log_request));
1425 psge = &mpi_request->SGL;
1426
1427 ioc->build_sg(ioc, psge, data_out_dma,
1428 sizeof(struct phy_control_request),
1429 data_out_dma + sizeof(struct phy_control_request),
1430 sizeof(struct phy_control_reply));
1431
1432 dtransportprintk(ioc,
1433 ioc_info(ioc, "phy_control - send to sas_addr(0x%016llx), phy(%d), opcode(%d)\n",
1434 (u64)phy->identify.sas_address,
1435 phy->number, phy_operation));
1436 init_completion(&ioc->transport_cmds.done);
1437 mpt3sas_base_put_smid_default(ioc, smid);
1438 wait_for_completion_timeout(&ioc->transport_cmds.done, 10*HZ);
1439
1440 if (!(ioc->transport_cmds.status & MPT3_CMD_COMPLETE)) {
1441 ioc_err(ioc, "%s: timeout\n", __func__);
1442 _debug_dump_mf(mpi_request,
1443 sizeof(Mpi2SmpPassthroughRequest_t)/4);
1444 if (!(ioc->transport_cmds.status & MPT3_CMD_RESET))
1445 issue_reset = 1;
1446 goto issue_host_reset;
1447 }
1448
1449 dtransportprintk(ioc, ioc_info(ioc, "phy_control - complete\n"));
1450
1451 if (ioc->transport_cmds.status & MPT3_CMD_REPLY_VALID) {
1452
1453 mpi_reply = ioc->transport_cmds.reply;
1454
1455 dtransportprintk(ioc,
1456 ioc_info(ioc, "phy_control - reply data transfer size(%d)\n",
1457 le16_to_cpu(mpi_reply->ResponseDataLength)));
1458
1459 if (le16_to_cpu(mpi_reply->ResponseDataLength) !=
1460 sizeof(struct phy_control_reply))
1461 goto out;
1462
1463 phy_control_reply = data_out +
1464 sizeof(struct phy_control_request);
1465
1466 dtransportprintk(ioc,
1467 ioc_info(ioc, "phy_control - function_result(%d)\n",
1468 phy_control_reply->function_result));
1469
1470 rc = 0;
1471 } else
1472 dtransportprintk(ioc,
1473 ioc_info(ioc, "phy_control - no reply\n"));
1474
1475 issue_host_reset:
1476 if (issue_reset)
1477 mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
1478 out:
1479 ioc->transport_cmds.status = MPT3_CMD_NOT_USED;
1480 if (data_out)
1481 dma_free_coherent(&ioc->pdev->dev, sz, data_out,
1482 data_out_dma);
1483
1484 mutex_unlock(&ioc->transport_cmds.mutex);
1485 return rc;
1486 }
1487
1488 /**
1489 * _transport_phy_reset -
1490 * @phy: The sas phy object
1491 * @hard_reset:
1492 *
1493 * Return: 0 for success, non-zero for failure.
1494 */
1495 static int
1496 _transport_phy_reset(struct sas_phy *phy, int hard_reset)
1497 {
1498 struct MPT3SAS_ADAPTER *ioc = phy_to_ioc(phy);
1499 Mpi2SasIoUnitControlReply_t mpi_reply;
1500 Mpi2SasIoUnitControlRequest_t mpi_request;
1501 unsigned long flags;
1502
1503 spin_lock_irqsave(&ioc->sas_node_lock, flags);
1504 if (_transport_sas_node_find_by_sas_address(ioc,
1505 phy->identify.sas_address) == NULL) {
1506 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1507 return -EINVAL;
1508 }
1509 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1510
1511 /* handle expander phys */
1512 if (phy->identify.sas_address != ioc->sas_hba.sas_address)
1513 return _transport_expander_phy_control(ioc, phy,
1514 (hard_reset == 1) ? SMP_PHY_CONTROL_HARD_RESET :
1515 SMP_PHY_CONTROL_LINK_RESET);
1516
1517 /* handle hba phys */
1518 memset(&mpi_request, 0, sizeof(Mpi2SasIoUnitControlRequest_t));
1519 mpi_request.Function = MPI2_FUNCTION_SAS_IO_UNIT_CONTROL;
1520 mpi_request.Operation = hard_reset ?
1521 MPI2_SAS_OP_PHY_HARD_RESET : MPI2_SAS_OP_PHY_LINK_RESET;
1522 mpi_request.PhyNum = phy->number;
1523
1524 if ((mpt3sas_base_sas_iounit_control(ioc, &mpi_reply, &mpi_request))) {
1525 ioc_err(ioc, "failure at %s:%d/%s()!\n",
1526 __FILE__, __LINE__, __func__);
1527 return -ENXIO;
1528 }
1529
1530 if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo)
1531 ioc_info(ioc, "phy(%d), ioc_status(0x%04x), loginfo(0x%08x)\n",
1532 phy->number, le16_to_cpu(mpi_reply.IOCStatus),
1533 le32_to_cpu(mpi_reply.IOCLogInfo));
1534
1535 return 0;
1536 }
1537
1538 /**
1539 * _transport_phy_enable - enable/disable phys
1540 * @phy: The sas phy object
1541 * @enable: enable phy when true
1542 *
1543 * Only support sas_host direct attached phys.
1544 * Return: 0 for success, non-zero for failure.
1545 */
1546 static int
1547 _transport_phy_enable(struct sas_phy *phy, int enable)
1548 {
1549 struct MPT3SAS_ADAPTER *ioc = phy_to_ioc(phy);
1550 Mpi2SasIOUnitPage1_t *sas_iounit_pg1 = NULL;
1551 Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL;
1552 Mpi2ConfigReply_t mpi_reply;
1553 u16 ioc_status;
1554 u16 sz;
1555 int rc = 0;
1556 unsigned long flags;
1557 int i, discovery_active;
1558
1559 spin_lock_irqsave(&ioc->sas_node_lock, flags);
1560 if (_transport_sas_node_find_by_sas_address(ioc,
1561 phy->identify.sas_address) == NULL) {
1562 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1563 return -EINVAL;
1564 }
1565 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1566
1567 /* handle expander phys */
1568 if (phy->identify.sas_address != ioc->sas_hba.sas_address)
1569 return _transport_expander_phy_control(ioc, phy,
1570 (enable == 1) ? SMP_PHY_CONTROL_LINK_RESET :
1571 SMP_PHY_CONTROL_DISABLE);
1572
1573 /* handle hba phys */
1574
1575 /* read sas_iounit page 0 */
1576 sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys *
1577 sizeof(Mpi2SasIOUnit0PhyData_t));
1578 sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL);
1579 if (!sas_iounit_pg0) {
1580 ioc_err(ioc, "failure at %s:%d/%s()!\n",
1581 __FILE__, __LINE__, __func__);
1582 rc = -ENOMEM;
1583 goto out;
1584 }
1585 if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
1586 sas_iounit_pg0, sz))) {
1587 ioc_err(ioc, "failure at %s:%d/%s()!\n",
1588 __FILE__, __LINE__, __func__);
1589 rc = -ENXIO;
1590 goto out;
1591 }
1592 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
1593 MPI2_IOCSTATUS_MASK;
1594 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
1595 ioc_err(ioc, "failure at %s:%d/%s()!\n",
1596 __FILE__, __LINE__, __func__);
1597 rc = -EIO;
1598 goto out;
1599 }
1600
1601 /* unable to enable/disable phys when when discovery is active */
1602 for (i = 0, discovery_active = 0; i < ioc->sas_hba.num_phys ; i++) {
1603 if (sas_iounit_pg0->PhyData[i].PortFlags &
1604 MPI2_SASIOUNIT0_PORTFLAGS_DISCOVERY_IN_PROGRESS) {
1605 ioc_err(ioc, "discovery is active on port = %d, phy = %d: unable to enable/disable phys, try again later!\n",
1606 sas_iounit_pg0->PhyData[i].Port, i);
1607 discovery_active = 1;
1608 }
1609 }
1610
1611 if (discovery_active) {
1612 rc = -EAGAIN;
1613 goto out;
1614 }
1615
1616 /* read sas_iounit page 1 */
1617 sz = offsetof(Mpi2SasIOUnitPage1_t, PhyData) + (ioc->sas_hba.num_phys *
1618 sizeof(Mpi2SasIOUnit1PhyData_t));
1619 sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL);
1620 if (!sas_iounit_pg1) {
1621 ioc_err(ioc, "failure at %s:%d/%s()!\n",
1622 __FILE__, __LINE__, __func__);
1623 rc = -ENOMEM;
1624 goto out;
1625 }
1626 if ((mpt3sas_config_get_sas_iounit_pg1(ioc, &mpi_reply,
1627 sas_iounit_pg1, sz))) {
1628 ioc_err(ioc, "failure at %s:%d/%s()!\n",
1629 __FILE__, __LINE__, __func__);
1630 rc = -ENXIO;
1631 goto out;
1632 }
1633 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
1634 MPI2_IOCSTATUS_MASK;
1635 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
1636 ioc_err(ioc, "failure at %s:%d/%s()!\n",
1637 __FILE__, __LINE__, __func__);
1638 rc = -EIO;
1639 goto out;
1640 }
1641
1642 /* copy Port/PortFlags/PhyFlags from page 0 */
1643 for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
1644 sas_iounit_pg1->PhyData[i].Port =
1645 sas_iounit_pg0->PhyData[i].Port;
1646 sas_iounit_pg1->PhyData[i].PortFlags =
1647 (sas_iounit_pg0->PhyData[i].PortFlags &
1648 MPI2_SASIOUNIT0_PORTFLAGS_AUTO_PORT_CONFIG);
1649 sas_iounit_pg1->PhyData[i].PhyFlags =
1650 (sas_iounit_pg0->PhyData[i].PhyFlags &
1651 (MPI2_SASIOUNIT0_PHYFLAGS_ZONING_ENABLED +
1652 MPI2_SASIOUNIT0_PHYFLAGS_PHY_DISABLED));
1653 }
1654
1655 if (enable)
1656 sas_iounit_pg1->PhyData[phy->number].PhyFlags
1657 &= ~MPI2_SASIOUNIT1_PHYFLAGS_PHY_DISABLE;
1658 else
1659 sas_iounit_pg1->PhyData[phy->number].PhyFlags
1660 |= MPI2_SASIOUNIT1_PHYFLAGS_PHY_DISABLE;
1661
1662 mpt3sas_config_set_sas_iounit_pg1(ioc, &mpi_reply, sas_iounit_pg1, sz);
1663
1664 /* link reset */
1665 if (enable)
1666 _transport_phy_reset(phy, 0);
1667
1668 out:
1669 kfree(sas_iounit_pg1);
1670 kfree(sas_iounit_pg0);
1671 return rc;
1672 }
1673
1674 /**
1675 * _transport_phy_speed - set phy min/max link rates
1676 * @phy: The sas phy object
1677 * @rates: rates defined in sas_phy_linkrates
1678 *
1679 * Only support sas_host direct attached phys.
1680 *
1681 * Return: 0 for success, non-zero for failure.
1682 */
1683 static int
1684 _transport_phy_speed(struct sas_phy *phy, struct sas_phy_linkrates *rates)
1685 {
1686 struct MPT3SAS_ADAPTER *ioc = phy_to_ioc(phy);
1687 Mpi2SasIOUnitPage1_t *sas_iounit_pg1 = NULL;
1688 Mpi2SasPhyPage0_t phy_pg0;
1689 Mpi2ConfigReply_t mpi_reply;
1690 u16 ioc_status;
1691 u16 sz;
1692 int i;
1693 int rc = 0;
1694 unsigned long flags;
1695
1696 spin_lock_irqsave(&ioc->sas_node_lock, flags);
1697 if (_transport_sas_node_find_by_sas_address(ioc,
1698 phy->identify.sas_address) == NULL) {
1699 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1700 return -EINVAL;
1701 }
1702 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
1703
1704 if (!rates->minimum_linkrate)
1705 rates->minimum_linkrate = phy->minimum_linkrate;
1706 else if (rates->minimum_linkrate < phy->minimum_linkrate_hw)
1707 rates->minimum_linkrate = phy->minimum_linkrate_hw;
1708
1709 if (!rates->maximum_linkrate)
1710 rates->maximum_linkrate = phy->maximum_linkrate;
1711 else if (rates->maximum_linkrate > phy->maximum_linkrate_hw)
1712 rates->maximum_linkrate = phy->maximum_linkrate_hw;
1713
1714 /* handle expander phys */
1715 if (phy->identify.sas_address != ioc->sas_hba.sas_address) {
1716 phy->minimum_linkrate = rates->minimum_linkrate;
1717 phy->maximum_linkrate = rates->maximum_linkrate;
1718 return _transport_expander_phy_control(ioc, phy,
1719 SMP_PHY_CONTROL_LINK_RESET);
1720 }
1721
1722 /* handle hba phys */
1723
1724 /* sas_iounit page 1 */
1725 sz = offsetof(Mpi2SasIOUnitPage1_t, PhyData) + (ioc->sas_hba.num_phys *
1726 sizeof(Mpi2SasIOUnit1PhyData_t));
1727 sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL);
1728 if (!sas_iounit_pg1) {
1729 ioc_err(ioc, "failure at %s:%d/%s()!\n",
1730 __FILE__, __LINE__, __func__);
1731 rc = -ENOMEM;
1732 goto out;
1733 }
1734 if ((mpt3sas_config_get_sas_iounit_pg1(ioc, &mpi_reply,
1735 sas_iounit_pg1, sz))) {
1736 ioc_err(ioc, "failure at %s:%d/%s()!\n",
1737 __FILE__, __LINE__, __func__);
1738 rc = -ENXIO;
1739 goto out;
1740 }
1741 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
1742 MPI2_IOCSTATUS_MASK;
1743 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
1744 ioc_err(ioc, "failure at %s:%d/%s()!\n",
1745 __FILE__, __LINE__, __func__);
1746 rc = -EIO;
1747 goto out;
1748 }
1749
1750 for (i = 0; i < ioc->sas_hba.num_phys; i++) {
1751 if (phy->number != i) {
1752 sas_iounit_pg1->PhyData[i].MaxMinLinkRate =
1753 (ioc->sas_hba.phy[i].phy->minimum_linkrate +
1754 (ioc->sas_hba.phy[i].phy->maximum_linkrate << 4));
1755 } else {
1756 sas_iounit_pg1->PhyData[i].MaxMinLinkRate =
1757 (rates->minimum_linkrate +
1758 (rates->maximum_linkrate << 4));
1759 }
1760 }
1761
1762 if (mpt3sas_config_set_sas_iounit_pg1(ioc, &mpi_reply, sas_iounit_pg1,
1763 sz)) {
1764 ioc_err(ioc, "failure at %s:%d/%s()!\n",
1765 __FILE__, __LINE__, __func__);
1766 rc = -ENXIO;
1767 goto out;
1768 }
1769
1770 /* link reset */
1771 _transport_phy_reset(phy, 0);
1772
1773 /* read phy page 0, then update the rates in the sas transport phy */
1774 if (!mpt3sas_config_get_phy_pg0(ioc, &mpi_reply, &phy_pg0,
1775 phy->number)) {
1776 phy->minimum_linkrate = _transport_convert_phy_link_rate(
1777 phy_pg0.ProgrammedLinkRate & MPI2_SAS_PRATE_MIN_RATE_MASK);
1778 phy->maximum_linkrate = _transport_convert_phy_link_rate(
1779 phy_pg0.ProgrammedLinkRate >> 4);
1780 phy->negotiated_linkrate = _transport_convert_phy_link_rate(
1781 phy_pg0.NegotiatedLinkRate &
1782 MPI2_SAS_NEG_LINK_RATE_MASK_PHYSICAL);
1783 }
1784
1785 out:
1786 kfree(sas_iounit_pg1);
1787 return rc;
1788 }
1789
1790 static int
1791 _transport_map_smp_buffer(struct device *dev, struct bsg_buffer *buf,
1792 dma_addr_t *dma_addr, size_t *dma_len, void **p)
1793 {
1794 /* Check if the request is split across multiple segments */
1795 if (buf->sg_cnt > 1) {
1796 *p = dma_alloc_coherent(dev, buf->payload_len, dma_addr,
1797 GFP_KERNEL);
1798 if (!*p)
1799 return -ENOMEM;
1800 *dma_len = buf->payload_len;
1801 } else {
1802 if (!dma_map_sg(dev, buf->sg_list, 1, DMA_BIDIRECTIONAL))
1803 return -ENOMEM;
1804 *dma_addr = sg_dma_address(buf->sg_list);
1805 *dma_len = sg_dma_len(buf->sg_list);
1806 *p = NULL;
1807 }
1808
1809 return 0;
1810 }
1811
1812 static void
1813 _transport_unmap_smp_buffer(struct device *dev, struct bsg_buffer *buf,
1814 dma_addr_t dma_addr, void *p)
1815 {
1816 if (p)
1817 dma_free_coherent(dev, buf->payload_len, p, dma_addr);
1818 else
1819 dma_unmap_sg(dev, buf->sg_list, 1, DMA_BIDIRECTIONAL);
1820 }
1821
1822 /**
1823 * _transport_smp_handler - transport portal for smp passthru
1824 * @job: ?
1825 * @shost: shost object
1826 * @rphy: sas transport rphy object
1827 *
1828 * This used primarily for smp_utils.
1829 * Example:
1830 * smp_rep_general /sys/class/bsg/expander-5:0
1831 */
1832 static void
1833 _transport_smp_handler(struct bsg_job *job, struct Scsi_Host *shost,
1834 struct sas_rphy *rphy)
1835 {
1836 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
1837 Mpi2SmpPassthroughRequest_t *mpi_request;
1838 Mpi2SmpPassthroughReply_t *mpi_reply;
1839 int rc;
1840 u16 smid;
1841 void *psge;
1842 dma_addr_t dma_addr_in;
1843 dma_addr_t dma_addr_out;
1844 void *addr_in = NULL;
1845 void *addr_out = NULL;
1846 size_t dma_len_in;
1847 size_t dma_len_out;
1848 unsigned int reslen = 0;
1849
1850 if (ioc->shost_recovery || ioc->pci_error_recovery) {
1851 ioc_info(ioc, "%s: host reset in progress!\n", __func__);
1852 rc = -EFAULT;
1853 goto job_done;
1854 }
1855
1856 rc = mutex_lock_interruptible(&ioc->transport_cmds.mutex);
1857 if (rc)
1858 goto job_done;
1859
1860 if (ioc->transport_cmds.status != MPT3_CMD_NOT_USED) {
1861 ioc_err(ioc, "%s: transport_cmds in use\n",
1862 __func__);
1863 rc = -EAGAIN;
1864 goto out;
1865 }
1866 ioc->transport_cmds.status = MPT3_CMD_PENDING;
1867
1868 rc = _transport_map_smp_buffer(&ioc->pdev->dev, &job->request_payload,
1869 &dma_addr_out, &dma_len_out, &addr_out);
1870 if (rc)
1871 goto out;
1872 if (addr_out) {
1873 sg_copy_to_buffer(job->request_payload.sg_list,
1874 job->request_payload.sg_cnt, addr_out,
1875 job->request_payload.payload_len);
1876 }
1877
1878 rc = _transport_map_smp_buffer(&ioc->pdev->dev, &job->reply_payload,
1879 &dma_addr_in, &dma_len_in, &addr_in);
1880 if (rc)
1881 goto unmap_out;
1882
1883 rc = mpt3sas_wait_for_ioc(ioc, IOC_OPERATIONAL_WAIT_COUNT);
1884 if (rc)
1885 goto unmap_in;
1886
1887 smid = mpt3sas_base_get_smid(ioc, ioc->transport_cb_idx);
1888 if (!smid) {
1889 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__);
1890 rc = -EAGAIN;
1891 goto unmap_in;
1892 }
1893
1894 rc = 0;
1895 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid);
1896 ioc->transport_cmds.smid = smid;
1897
1898 memset(mpi_request, 0, sizeof(Mpi2SmpPassthroughRequest_t));
1899 mpi_request->Function = MPI2_FUNCTION_SMP_PASSTHROUGH;
1900 mpi_request->PhysicalPort = 0xFF;
1901 mpi_request->SASAddress = (rphy) ?
1902 cpu_to_le64(rphy->identify.sas_address) :
1903 cpu_to_le64(ioc->sas_hba.sas_address);
1904 mpi_request->RequestDataLength = cpu_to_le16(dma_len_out - 4);
1905 psge = &mpi_request->SGL;
1906
1907 ioc->build_sg(ioc, psge, dma_addr_out, dma_len_out - 4, dma_addr_in,
1908 dma_len_in - 4);
1909
1910 dtransportprintk(ioc,
1911 ioc_info(ioc, "%s: sending smp request\n", __func__));
1912
1913 init_completion(&ioc->transport_cmds.done);
1914 mpt3sas_base_put_smid_default(ioc, smid);
1915 wait_for_completion_timeout(&ioc->transport_cmds.done, 10*HZ);
1916
1917 if (!(ioc->transport_cmds.status & MPT3_CMD_COMPLETE)) {
1918 ioc_err(ioc, "%s: timeout\n", __func__);
1919 _debug_dump_mf(mpi_request,
1920 sizeof(Mpi2SmpPassthroughRequest_t)/4);
1921 if (!(ioc->transport_cmds.status & MPT3_CMD_RESET)) {
1922 mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER);
1923 rc = -ETIMEDOUT;
1924 goto unmap_in;
1925 }
1926 }
1927
1928 dtransportprintk(ioc, ioc_info(ioc, "%s - complete\n", __func__));
1929
1930 if (!(ioc->transport_cmds.status & MPT3_CMD_REPLY_VALID)) {
1931 dtransportprintk(ioc,
1932 ioc_info(ioc, "%s: no reply\n", __func__));
1933 rc = -ENXIO;
1934 goto unmap_in;
1935 }
1936
1937 mpi_reply = ioc->transport_cmds.reply;
1938
1939 dtransportprintk(ioc,
1940 ioc_info(ioc, "%s: reply data transfer size(%d)\n",
1941 __func__,
1942 le16_to_cpu(mpi_reply->ResponseDataLength)));
1943
1944 memcpy(job->reply, mpi_reply, sizeof(*mpi_reply));
1945 job->reply_len = sizeof(*mpi_reply);
1946 reslen = le16_to_cpu(mpi_reply->ResponseDataLength);
1947
1948 if (addr_in) {
1949 sg_copy_to_buffer(job->reply_payload.sg_list,
1950 job->reply_payload.sg_cnt, addr_in,
1951 job->reply_payload.payload_len);
1952 }
1953
1954 rc = 0;
1955 unmap_in:
1956 _transport_unmap_smp_buffer(&ioc->pdev->dev, &job->reply_payload,
1957 dma_addr_in, addr_in);
1958 unmap_out:
1959 _transport_unmap_smp_buffer(&ioc->pdev->dev, &job->request_payload,
1960 dma_addr_out, addr_out);
1961 out:
1962 ioc->transport_cmds.status = MPT3_CMD_NOT_USED;
1963 mutex_unlock(&ioc->transport_cmds.mutex);
1964 job_done:
1965 bsg_job_done(job, rc, reslen);
1966 }
1967
1968 struct sas_function_template mpt3sas_transport_functions = {
1969 .get_linkerrors = _transport_get_linkerrors,
1970 .get_enclosure_identifier = _transport_get_enclosure_identifier,
1971 .get_bay_identifier = _transport_get_bay_identifier,
1972 .phy_reset = _transport_phy_reset,
1973 .phy_enable = _transport_phy_enable,
1974 .set_phy_speed = _transport_phy_speed,
1975 .smp_handler = _transport_smp_handler,
1976 };
1977
1978 struct scsi_transport_template *mpt3sas_transport_template;
Linux with added FPC-III support