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