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