2 * This file is provided under a dual BSD/GPLv2 license. When using or
3 * redistributing this file, you may do so under either license.
7 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of version 2 of the GNU General Public License as
11 * published by the Free Software Foundation.
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
21 * The full GNU General Public License is included in this distribution
22 * in the file called LICENSE.GPL.
26 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
27 * All rights reserved.
29 * Redistribution and use in source and binary forms, with or without
30 * modification, are permitted provided that the following conditions
33 * * Redistributions of source code must retain the above copyright
34 * notice, this list of conditions and the following disclaimer.
35 * * Redistributions in binary form must reproduce the above copyright
36 * notice, this list of conditions and the following disclaimer in
37 * the documentation and/or other materials provided with the
39 * * Neither the name of Intel Corporation nor the names of its
40 * contributors may be used to endorse or promote products derived
41 * from this software without specific prior written permission.
43 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
44 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
45 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
46 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
47 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
48 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
49 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
50 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
51 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
52 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
53 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
55 #include "intel_sas.h"
59 #include "remote_device.h"
61 #include "scic_controller.h"
62 #include "scic_io_request.h"
64 #include "scic_port.h"
65 #include "scic_sds_controller.h"
66 #include "scic_sds_phy.h"
67 #include "scic_sds_port.h"
68 #include "remote_node_context.h"
69 #include "scic_sds_request.h"
70 #include "sci_environment.h"
72 #include "scu_event_codes.h"
76 * isci_remote_device_change_state() - This function gets the status of the
77 * remote_device object.
78 * @isci_device: This parameter points to the isci_remote_device object
80 * status of the object as a isci_status enum.
82 void isci_remote_device_change_state(
83 struct isci_remote_device *isci_device,
84 enum isci_status status)
88 spin_lock_irqsave(&isci_device->state_lock, flags);
89 isci_device->status = status;
90 spin_unlock_irqrestore(&isci_device->state_lock, flags);
94 * isci_remote_device_not_ready() - This function is called by the scic when
95 * the remote device is not ready. We mark the isci device as ready (not
96 * "ready_for_io") and signal the waiting proccess.
97 * @isci_host: This parameter specifies the isci host object.
98 * @isci_device: This parameter specifies the remote device
101 static void isci_remote_device_not_ready(struct isci_host *ihost,
102 struct isci_remote_device *idev, u32 reason)
104 dev_dbg(&ihost->pdev->dev,
105 "%s: isci_device = %p\n", __func__, idev);
107 if (reason == SCIC_REMOTE_DEVICE_NOT_READY_STOP_REQUESTED)
108 isci_remote_device_change_state(idev, isci_stopping);
110 /* device ready is actually a "not ready for io" state. */
111 isci_remote_device_change_state(idev, isci_ready);
115 * isci_remote_device_ready() - This function is called by the scic when the
116 * remote device is ready. We mark the isci device as ready and signal the
118 * @ihost: our valid isci_host
119 * @idev: remote device
122 static void isci_remote_device_ready(struct isci_host *ihost, struct isci_remote_device *idev)
124 dev_dbg(&ihost->pdev->dev,
125 "%s: idev = %p\n", __func__, idev);
127 isci_remote_device_change_state(idev, isci_ready_for_io);
128 if (test_and_clear_bit(IDEV_START_PENDING, &idev->flags))
129 wake_up(&ihost->eventq);
132 /* called once the remote node context is ready to be freed.
133 * The remote device can now report that its stop operation is complete. none
135 static void rnc_destruct_done(void *_dev)
137 struct scic_sds_remote_device *sci_dev = _dev;
139 BUG_ON(sci_dev->started_request_count != 0);
140 sci_base_state_machine_change_state(&sci_dev->state_machine,
141 SCI_BASE_REMOTE_DEVICE_STATE_STOPPED);
144 static enum sci_status scic_sds_remote_device_terminate_requests(struct scic_sds_remote_device *sci_dev)
146 struct scic_sds_controller *scic = sci_dev->owning_port->owning_controller;
147 u32 i, request_count = sci_dev->started_request_count;
148 enum sci_status status = SCI_SUCCESS;
150 for (i = 0; i < SCI_MAX_IO_REQUESTS && i < request_count; i++) {
151 struct scic_sds_request *sci_req;
154 sci_req = scic->io_request_table[i];
155 if (!sci_req || sci_req->target_device != sci_dev)
157 s = scic_controller_terminate_request(scic, sci_dev, sci_req);
158 if (s != SCI_SUCCESS)
165 enum sci_status scic_remote_device_stop(struct scic_sds_remote_device *sci_dev,
168 struct sci_base_state_machine *sm = &sci_dev->state_machine;
169 enum scic_sds_remote_device_states state = sm->current_state_id;
172 case SCI_BASE_REMOTE_DEVICE_STATE_INITIAL:
173 case SCI_BASE_REMOTE_DEVICE_STATE_FAILED:
174 case SCI_BASE_REMOTE_DEVICE_STATE_FINAL:
176 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
178 return SCI_FAILURE_INVALID_STATE;
179 case SCI_BASE_REMOTE_DEVICE_STATE_STOPPED:
181 case SCI_BASE_REMOTE_DEVICE_STATE_STARTING:
182 /* device not started so there had better be no requests */
183 BUG_ON(sci_dev->started_request_count != 0);
184 scic_sds_remote_node_context_destruct(&sci_dev->rnc,
185 rnc_destruct_done, sci_dev);
186 /* Transition to the stopping state and wait for the
187 * remote node to complete being posted and invalidated.
189 sci_base_state_machine_change_state(sm, SCI_BASE_REMOTE_DEVICE_STATE_STOPPING);
191 case SCI_BASE_REMOTE_DEVICE_STATE_READY:
192 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
193 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
194 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ:
195 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR:
196 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET:
197 case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
198 case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
199 sci_base_state_machine_change_state(sm, SCI_BASE_REMOTE_DEVICE_STATE_STOPPING);
200 if (sci_dev->started_request_count == 0) {
201 scic_sds_remote_node_context_destruct(&sci_dev->rnc,
202 rnc_destruct_done, sci_dev);
205 return scic_sds_remote_device_terminate_requests(sci_dev);
207 case SCI_BASE_REMOTE_DEVICE_STATE_STOPPING:
208 /* All requests should have been terminated, but if there is an
209 * attempt to stop a device already in the stopping state, then
210 * try again to terminate.
212 return scic_sds_remote_device_terminate_requests(sci_dev);
213 case SCI_BASE_REMOTE_DEVICE_STATE_RESETTING:
214 sci_base_state_machine_change_state(sm, SCI_BASE_REMOTE_DEVICE_STATE_STOPPING);
219 enum sci_status scic_remote_device_reset(struct scic_sds_remote_device *sci_dev)
221 struct sci_base_state_machine *sm = &sci_dev->state_machine;
222 enum scic_sds_remote_device_states state = sm->current_state_id;
225 case SCI_BASE_REMOTE_DEVICE_STATE_INITIAL:
226 case SCI_BASE_REMOTE_DEVICE_STATE_STOPPED:
227 case SCI_BASE_REMOTE_DEVICE_STATE_STARTING:
228 case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
229 case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
230 case SCI_BASE_REMOTE_DEVICE_STATE_STOPPING:
231 case SCI_BASE_REMOTE_DEVICE_STATE_FAILED:
232 case SCI_BASE_REMOTE_DEVICE_STATE_RESETTING:
233 case SCI_BASE_REMOTE_DEVICE_STATE_FINAL:
235 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
237 return SCI_FAILURE_INVALID_STATE;
238 case SCI_BASE_REMOTE_DEVICE_STATE_READY:
239 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
240 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
241 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ:
242 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR:
243 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET:
244 sci_base_state_machine_change_state(sm, SCI_BASE_REMOTE_DEVICE_STATE_RESETTING);
249 enum sci_status scic_remote_device_reset_complete(struct scic_sds_remote_device *sci_dev)
251 struct sci_base_state_machine *sm = &sci_dev->state_machine;
252 enum scic_sds_remote_device_states state = sm->current_state_id;
254 if (state != SCI_BASE_REMOTE_DEVICE_STATE_RESETTING) {
255 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
257 return SCI_FAILURE_INVALID_STATE;
260 sci_base_state_machine_change_state(sm, SCI_BASE_REMOTE_DEVICE_STATE_READY);
264 enum sci_status scic_sds_remote_device_suspend(struct scic_sds_remote_device *sci_dev,
267 struct sci_base_state_machine *sm = &sci_dev->state_machine;
268 enum scic_sds_remote_device_states state = sm->current_state_id;
270 if (state != SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD) {
271 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
273 return SCI_FAILURE_INVALID_STATE;
276 return scic_sds_remote_node_context_suspend(&sci_dev->rnc,
277 suspend_type, NULL, NULL);
280 enum sci_status scic_sds_remote_device_frame_handler(struct scic_sds_remote_device *sci_dev,
283 struct sci_base_state_machine *sm = &sci_dev->state_machine;
284 enum scic_sds_remote_device_states state = sm->current_state_id;
285 struct scic_sds_controller *scic = sci_dev->owning_port->owning_controller;
286 enum sci_status status;
289 case SCI_BASE_REMOTE_DEVICE_STATE_INITIAL:
290 case SCI_BASE_REMOTE_DEVICE_STATE_STOPPED:
291 case SCI_BASE_REMOTE_DEVICE_STATE_STARTING:
292 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
293 case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
294 case SCI_BASE_REMOTE_DEVICE_STATE_FINAL:
296 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
298 /* Return the frame back to the controller */
299 scic_sds_controller_release_frame(scic, frame_index);
300 return SCI_FAILURE_INVALID_STATE;
301 case SCI_BASE_REMOTE_DEVICE_STATE_READY:
302 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR:
303 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET:
304 case SCI_BASE_REMOTE_DEVICE_STATE_STOPPING:
305 case SCI_BASE_REMOTE_DEVICE_STATE_FAILED:
306 case SCI_BASE_REMOTE_DEVICE_STATE_RESETTING: {
307 struct scic_sds_request *sci_req;
308 struct sci_ssp_frame_header *hdr;
310 status = scic_sds_unsolicited_frame_control_get_header(&scic->uf_control,
313 if (status != SCI_SUCCESS)
316 sci_req = scic_sds_controller_get_io_request_from_tag(scic, hdr->tag);
317 if (sci_req && sci_req->target_device == sci_dev) {
318 /* The IO request is now in charge of releasing the frame */
319 status = sci_req->state_handlers->frame_handler(sci_req,
322 /* We could not map this tag to a valid IO
323 * request Just toss the frame and continue
325 scic_sds_controller_release_frame(scic, frame_index);
329 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ: {
330 struct dev_to_host_fis *hdr;
332 status = scic_sds_unsolicited_frame_control_get_header(&scic->uf_control,
335 if (status != SCI_SUCCESS)
338 if (hdr->fis_type == FIS_SETDEVBITS &&
339 (hdr->status & ATA_ERR)) {
340 sci_dev->not_ready_reason = SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED;
342 /* TODO Check sactive and complete associated IO if any. */
343 sci_base_state_machine_change_state(sm, SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR);
344 } else if (hdr->fis_type == FIS_REGD2H &&
345 (hdr->status & ATA_ERR)) {
347 * Some devices return D2H FIS when an NCQ error is detected.
348 * Treat this like an SDB error FIS ready reason.
350 sci_dev->not_ready_reason = SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED;
351 sci_base_state_machine_change_state(&sci_dev->state_machine,
352 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR);
354 status = SCI_FAILURE;
356 scic_sds_controller_release_frame(scic, frame_index);
359 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
360 case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
361 /* The device does not process any UF received from the hardware while
362 * in this state. All unsolicited frames are forwarded to the io request
365 status = scic_sds_io_request_frame_handler(sci_dev->working_request, frame_index);
372 static bool is_remote_device_ready(struct scic_sds_remote_device *sci_dev)
375 struct sci_base_state_machine *sm = &sci_dev->state_machine;
376 enum scic_sds_remote_device_states state = sm->current_state_id;
379 case SCI_BASE_REMOTE_DEVICE_STATE_READY:
380 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
381 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
382 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ:
383 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR:
384 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET:
385 case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
386 case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
393 enum sci_status scic_sds_remote_device_event_handler(struct scic_sds_remote_device *sci_dev,
396 struct sci_base_state_machine *sm = &sci_dev->state_machine;
397 enum scic_sds_remote_device_states state = sm->current_state_id;
398 enum sci_status status;
400 switch (scu_get_event_type(event_code)) {
401 case SCU_EVENT_TYPE_RNC_OPS_MISC:
402 case SCU_EVENT_TYPE_RNC_SUSPEND_TX:
403 case SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX:
404 status = scic_sds_remote_node_context_event_handler(&sci_dev->rnc, event_code);
406 case SCU_EVENT_TYPE_PTX_SCHEDULE_EVENT:
407 if (scu_get_event_code(event_code) == SCU_EVENT_IT_NEXUS_TIMEOUT) {
408 status = SCI_SUCCESS;
410 /* Suspend the associated RNC */
411 scic_sds_remote_node_context_suspend(&sci_dev->rnc,
412 SCI_SOFTWARE_SUSPENSION,
415 dev_dbg(scirdev_to_dev(sci_dev),
416 "%s: device: %p event code: %x: %s\n",
417 __func__, sci_dev, event_code,
418 is_remote_device_ready(sci_dev)
419 ? "I_T_Nexus_Timeout event"
420 : "I_T_Nexus_Timeout event in wrong state");
424 /* Else, fall through and treat as unhandled... */
426 dev_dbg(scirdev_to_dev(sci_dev),
427 "%s: device: %p event code: %x: %s\n",
428 __func__, sci_dev, event_code,
429 is_remote_device_ready(sci_dev)
431 : "unexpected event in wrong state");
432 status = SCI_FAILURE_INVALID_STATE;
436 if (status != SCI_SUCCESS)
439 if (state == SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE) {
441 /* We pick up suspension events to handle specifically to this
442 * state. We resume the RNC right away.
444 if (scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX ||
445 scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX)
446 status = scic_sds_remote_node_context_resume(&sci_dev->rnc, NULL, NULL);
452 static void scic_sds_remote_device_start_request(struct scic_sds_remote_device *sci_dev,
453 struct scic_sds_request *sci_req,
454 enum sci_status status)
456 struct scic_sds_port *sci_port = sci_dev->owning_port;
458 /* cleanup requests that failed after starting on the port */
459 if (status != SCI_SUCCESS)
460 scic_sds_port_complete_io(sci_port, sci_dev, sci_req);
462 scic_sds_remote_device_increment_request_count(sci_dev);
465 enum sci_status scic_sds_remote_device_start_io(struct scic_sds_controller *scic,
466 struct scic_sds_remote_device *sci_dev,
467 struct scic_sds_request *sci_req)
469 struct sci_base_state_machine *sm = &sci_dev->state_machine;
470 enum scic_sds_remote_device_states state = sm->current_state_id;
471 struct scic_sds_port *sci_port = sci_dev->owning_port;
472 struct isci_request *ireq = sci_req->ireq;
473 enum sci_status status;
476 case SCI_BASE_REMOTE_DEVICE_STATE_INITIAL:
477 case SCI_BASE_REMOTE_DEVICE_STATE_STOPPED:
478 case SCI_BASE_REMOTE_DEVICE_STATE_STARTING:
479 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR:
480 case SCI_BASE_REMOTE_DEVICE_STATE_STOPPING:
481 case SCI_BASE_REMOTE_DEVICE_STATE_FAILED:
482 case SCI_BASE_REMOTE_DEVICE_STATE_RESETTING:
483 case SCI_BASE_REMOTE_DEVICE_STATE_FINAL:
485 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
487 return SCI_FAILURE_INVALID_STATE;
488 case SCI_BASE_REMOTE_DEVICE_STATE_READY:
489 /* attempt to start an io request for this device object. The remote
490 * device object will issue the start request for the io and if
491 * successful it will start the request for the port object then
492 * increment its own request count.
494 status = scic_sds_port_start_io(sci_port, sci_dev, sci_req);
495 if (status != SCI_SUCCESS)
498 status = scic_sds_remote_node_context_start_io(&sci_dev->rnc, sci_req);
499 if (status != SCI_SUCCESS)
502 status = scic_sds_request_start(sci_req);
504 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE: {
505 /* handle the start io operation for a sata device that is in
506 * the command idle state. - Evalute the type of IO request to
507 * be started - If its an NCQ request change to NCQ substate -
508 * If its any other command change to the CMD substate
510 * If this is a softreset we may want to have a different
513 enum scic_sds_remote_device_states new_state;
514 struct sas_task *task = isci_request_access_task(ireq);
516 status = scic_sds_port_start_io(sci_port, sci_dev, sci_req);
517 if (status != SCI_SUCCESS)
520 status = scic_sds_remote_node_context_start_io(&sci_dev->rnc, sci_req);
521 if (status != SCI_SUCCESS)
524 status = sci_req->state_handlers->start_handler(sci_req);
525 if (status != SCI_SUCCESS)
528 if (task->ata_task.use_ncq)
529 new_state = SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ;
531 sci_dev->working_request = sci_req;
532 new_state = SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD;
534 sci_base_state_machine_change_state(sm, new_state);
537 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ: {
538 struct sas_task *task = isci_request_access_task(ireq);
540 if (task->ata_task.use_ncq) {
541 status = scic_sds_port_start_io(sci_port, sci_dev, sci_req);
542 if (status != SCI_SUCCESS)
545 status = scic_sds_remote_node_context_start_io(&sci_dev->rnc, sci_req);
546 if (status != SCI_SUCCESS)
549 status = sci_req->state_handlers->start_handler(sci_req);
551 return SCI_FAILURE_INVALID_STATE;
554 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET:
555 return SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
556 case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
557 status = scic_sds_port_start_io(sci_port, sci_dev, sci_req);
558 if (status != SCI_SUCCESS)
561 status = scic_sds_remote_node_context_start_io(&sci_dev->rnc, sci_req);
562 if (status != SCI_SUCCESS)
565 status = scic_sds_request_start(sci_req);
566 if (status != SCI_SUCCESS)
569 sci_dev->working_request = sci_req;
570 sci_base_state_machine_change_state(&sci_dev->state_machine,
571 SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD);
573 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
574 case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
575 /* device is already handling a command it can not accept new commands
576 * until this one is complete.
578 return SCI_FAILURE_INVALID_STATE;
581 scic_sds_remote_device_start_request(sci_dev, sci_req, status);
585 static enum sci_status common_complete_io(struct scic_sds_port *sci_port,
586 struct scic_sds_remote_device *sci_dev,
587 struct scic_sds_request *sci_req)
589 enum sci_status status;
591 status = scic_sds_request_complete(sci_req);
592 if (status != SCI_SUCCESS)
595 status = scic_sds_port_complete_io(sci_port, sci_dev, sci_req);
596 if (status != SCI_SUCCESS)
599 scic_sds_remote_device_decrement_request_count(sci_dev);
603 enum sci_status scic_sds_remote_device_complete_io(struct scic_sds_controller *scic,
604 struct scic_sds_remote_device *sci_dev,
605 struct scic_sds_request *sci_req)
607 struct sci_base_state_machine *sm = &sci_dev->state_machine;
608 enum scic_sds_remote_device_states state = sm->current_state_id;
609 struct scic_sds_port *sci_port = sci_dev->owning_port;
610 enum sci_status status;
613 case SCI_BASE_REMOTE_DEVICE_STATE_INITIAL:
614 case SCI_BASE_REMOTE_DEVICE_STATE_STOPPED:
615 case SCI_BASE_REMOTE_DEVICE_STATE_STARTING:
616 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
617 case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
618 case SCI_BASE_REMOTE_DEVICE_STATE_FAILED:
619 case SCI_BASE_REMOTE_DEVICE_STATE_FINAL:
621 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
623 return SCI_FAILURE_INVALID_STATE;
624 case SCI_BASE_REMOTE_DEVICE_STATE_READY:
625 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET:
626 case SCI_BASE_REMOTE_DEVICE_STATE_RESETTING:
627 status = common_complete_io(sci_port, sci_dev, sci_req);
629 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
630 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ:
631 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR:
632 status = common_complete_io(sci_port, sci_dev, sci_req);
633 if (status != SCI_SUCCESS)
636 if (sci_req->sci_status == SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED) {
637 /* This request causes hardware error, device needs to be Lun Reset.
638 * So here we force the state machine to IDLE state so the rest IOs
639 * can reach RNC state handler, these IOs will be completed by RNC with
640 * status of "DEVICE_RESET_REQUIRED", instead of "INVALID STATE".
642 sci_base_state_machine_change_state(sm, SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET);
643 } else if (scic_sds_remote_device_get_request_count(sci_dev) == 0)
644 sci_base_state_machine_change_state(sm, SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE);
646 case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
647 status = common_complete_io(sci_port, sci_dev, sci_req);
648 if (status != SCI_SUCCESS)
650 sci_base_state_machine_change_state(sm, SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE);
652 case SCI_BASE_REMOTE_DEVICE_STATE_STOPPING:
653 status = common_complete_io(sci_port, sci_dev, sci_req);
654 if (status != SCI_SUCCESS)
657 if (scic_sds_remote_device_get_request_count(sci_dev) == 0)
658 scic_sds_remote_node_context_destruct(&sci_dev->rnc,
664 if (status != SCI_SUCCESS)
665 dev_err(scirdev_to_dev(sci_dev),
666 "%s: Port:0x%p Device:0x%p Request:0x%p Status:0x%x "
667 "could not complete\n", __func__, sci_port,
668 sci_dev, sci_req, status);
673 static void scic_sds_remote_device_continue_request(void *dev)
675 struct scic_sds_remote_device *sci_dev = dev;
677 /* we need to check if this request is still valid to continue. */
678 if (sci_dev->working_request)
679 scic_controller_continue_io(sci_dev->working_request);
682 enum sci_status scic_sds_remote_device_start_task(struct scic_sds_controller *scic,
683 struct scic_sds_remote_device *sci_dev,
684 struct scic_sds_request *sci_req)
686 struct sci_base_state_machine *sm = &sci_dev->state_machine;
687 enum scic_sds_remote_device_states state = sm->current_state_id;
688 struct scic_sds_port *sci_port = sci_dev->owning_port;
689 enum sci_status status;
692 case SCI_BASE_REMOTE_DEVICE_STATE_INITIAL:
693 case SCI_BASE_REMOTE_DEVICE_STATE_STOPPED:
694 case SCI_BASE_REMOTE_DEVICE_STATE_STARTING:
695 case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
696 case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
697 case SCI_BASE_REMOTE_DEVICE_STATE_STOPPING:
698 case SCI_BASE_REMOTE_DEVICE_STATE_FAILED:
699 case SCI_BASE_REMOTE_DEVICE_STATE_RESETTING:
700 case SCI_BASE_REMOTE_DEVICE_STATE_FINAL:
702 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
704 return SCI_FAILURE_INVALID_STATE;
705 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
706 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
707 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ:
708 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR:
709 case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET:
710 status = scic_sds_port_start_io(sci_port, sci_dev, sci_req);
711 if (status != SCI_SUCCESS)
714 status = scic_sds_remote_node_context_start_task(&sci_dev->rnc, sci_req);
715 if (status != SCI_SUCCESS)
718 status = sci_req->state_handlers->start_handler(sci_req);
719 if (status != SCI_SUCCESS)
722 /* Note: If the remote device state is not IDLE this will
723 * replace the request that probably resulted in the task
724 * management request.
726 sci_dev->working_request = sci_req;
727 sci_base_state_machine_change_state(sm, SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD);
729 /* The remote node context must cleanup the TCi to NCQ mapping
730 * table. The only way to do this correctly is to either write
731 * to the TLCR register or to invalidate and repost the RNC. In
732 * either case the remote node context state machine will take
733 * the correct action when the remote node context is suspended
736 scic_sds_remote_node_context_suspend(&sci_dev->rnc,
737 SCI_SOFTWARE_SUSPENSION, NULL, NULL);
738 scic_sds_remote_node_context_resume(&sci_dev->rnc,
739 scic_sds_remote_device_continue_request,
743 scic_sds_remote_device_start_request(sci_dev, sci_req, status);
744 /* We need to let the controller start request handler know that
745 * it can't post TC yet. We will provide a callback function to
746 * post TC when RNC gets resumed.
748 return SCI_FAILURE_RESET_DEVICE_PARTIAL_SUCCESS;
749 case SCI_BASE_REMOTE_DEVICE_STATE_READY:
750 status = scic_sds_port_start_io(sci_port, sci_dev, sci_req);
751 if (status != SCI_SUCCESS)
754 status = scic_sds_remote_node_context_start_task(&sci_dev->rnc, sci_req);
755 if (status != SCI_SUCCESS)
758 status = scic_sds_request_start(sci_req);
761 scic_sds_remote_device_start_request(sci_dev, sci_req, status);
771 * This method takes the request and bulids an appropriate SCU context for the
772 * request and then requests the controller to post the request. none
774 void scic_sds_remote_device_post_request(
775 struct scic_sds_remote_device *sci_dev,
780 context = scic_sds_remote_device_build_command_context(sci_dev, request);
782 scic_sds_controller_post_request(
783 scic_sds_remote_device_get_controller(sci_dev),
788 /* called once the remote node context has transisitioned to a
789 * ready state. This is the indication that the remote device object can also
790 * transition to ready.
792 static void remote_device_resume_done(void *_dev)
794 struct scic_sds_remote_device *sci_dev = _dev;
796 if (is_remote_device_ready(sci_dev))
799 /* go 'ready' if we are not already in a ready state */
800 sci_base_state_machine_change_state(&sci_dev->state_machine,
801 SCI_BASE_REMOTE_DEVICE_STATE_READY);
804 static void scic_sds_stp_remote_device_ready_idle_substate_resume_complete_handler(void *_dev)
806 struct scic_sds_remote_device *sci_dev = _dev;
807 struct isci_remote_device *idev = sci_dev_to_idev(sci_dev);
808 struct scic_sds_controller *scic = sci_dev->owning_port->owning_controller;
810 /* For NCQ operation we do not issue a isci_remote_device_not_ready().
811 * As a result, avoid sending the ready notification.
813 if (sci_dev->state_machine.previous_state_id != SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ)
814 isci_remote_device_ready(scic->ihost, idev);
817 static void scic_sds_remote_device_initial_state_enter(void *object)
819 struct scic_sds_remote_device *sci_dev = object;
821 /* Initial state is a transitional state to the stopped state */
822 sci_base_state_machine_change_state(&sci_dev->state_machine,
823 SCI_BASE_REMOTE_DEVICE_STATE_STOPPED);
827 * scic_remote_device_destruct() - free remote node context and destruct
828 * @remote_device: This parameter specifies the remote device to be destructed.
830 * Remote device objects are a limited resource. As such, they must be
831 * protected. Thus calls to construct and destruct are mutually exclusive and
832 * non-reentrant. The return value shall indicate if the device was
833 * successfully destructed or if some failure occurred. enum sci_status This value
834 * is returned if the device is successfully destructed.
835 * SCI_FAILURE_INVALID_REMOTE_DEVICE This value is returned if the supplied
836 * device isn't valid (e.g. it's already been destoryed, the handle isn't
839 static enum sci_status scic_remote_device_destruct(struct scic_sds_remote_device *sci_dev)
841 struct sci_base_state_machine *sm = &sci_dev->state_machine;
842 enum scic_sds_remote_device_states state = sm->current_state_id;
843 struct scic_sds_controller *scic;
845 if (state != SCI_BASE_REMOTE_DEVICE_STATE_STOPPED) {
846 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
848 return SCI_FAILURE_INVALID_STATE;
851 scic = sci_dev->owning_port->owning_controller;
852 scic_sds_controller_free_remote_node_context(scic, sci_dev,
853 sci_dev->rnc.remote_node_index);
854 sci_dev->rnc.remote_node_index = SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX;
855 sci_base_state_machine_change_state(sm, SCI_BASE_REMOTE_DEVICE_STATE_FINAL);
861 * isci_remote_device_deconstruct() - This function frees an isci_remote_device.
862 * @ihost: This parameter specifies the isci host object.
863 * @idev: This parameter specifies the remote device to be freed.
866 static void isci_remote_device_deconstruct(struct isci_host *ihost, struct isci_remote_device *idev)
868 dev_dbg(&ihost->pdev->dev,
869 "%s: isci_device = %p\n", __func__, idev);
871 /* There should not be any outstanding io's. All paths to
872 * here should go through isci_remote_device_nuke_requests.
873 * If we hit this condition, we will need a way to complete
874 * io requests in process */
875 while (!list_empty(&idev->reqs_in_process)) {
877 dev_err(&ihost->pdev->dev,
878 "%s: ** request list not empty! **\n", __func__);
882 scic_remote_device_destruct(&idev->sci);
883 idev->domain_dev->lldd_dev = NULL;
884 idev->domain_dev = NULL;
885 idev->isci_port = NULL;
886 list_del_init(&idev->node);
888 clear_bit(IDEV_START_PENDING, &idev->flags);
889 clear_bit(IDEV_STOP_PENDING, &idev->flags);
890 wake_up(&ihost->eventq);
894 * isci_remote_device_stop_complete() - This function is called by the scic
895 * when the remote device stop has completed. We mark the isci device as not
896 * ready and remove the isci remote device.
897 * @ihost: This parameter specifies the isci host object.
898 * @idev: This parameter specifies the remote device.
899 * @status: This parameter specifies status of the completion.
902 static void isci_remote_device_stop_complete(struct isci_host *ihost,
903 struct isci_remote_device *idev)
905 dev_dbg(&ihost->pdev->dev, "%s: complete idev = %p\n", __func__, idev);
907 isci_remote_device_change_state(idev, isci_stopped);
909 /* after stop, we can tear down resources. */
910 isci_remote_device_deconstruct(ihost, idev);
913 static void scic_sds_remote_device_stopped_state_enter(void *object)
915 struct scic_sds_remote_device *sci_dev = object;
916 struct scic_sds_controller *scic;
917 struct isci_remote_device *idev;
918 struct isci_host *ihost;
921 scic = scic_sds_remote_device_get_controller(sci_dev);
923 idev = sci_dev_to_idev(sci_dev);
925 /* If we are entering from the stopping state let the SCI User know that
926 * the stop operation has completed.
928 prev_state = sci_dev->state_machine.previous_state_id;
929 if (prev_state == SCI_BASE_REMOTE_DEVICE_STATE_STOPPING)
930 isci_remote_device_stop_complete(ihost, idev);
932 scic_sds_controller_remote_device_stopped(scic, sci_dev);
935 static void scic_sds_remote_device_starting_state_enter(void *object)
937 struct scic_sds_remote_device *sci_dev = object;
938 struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev);
939 struct isci_host *ihost = scic->ihost;
940 struct isci_remote_device *idev = sci_dev_to_idev(sci_dev);
942 isci_remote_device_not_ready(ihost, idev,
943 SCIC_REMOTE_DEVICE_NOT_READY_START_REQUESTED);
946 static void scic_sds_remote_device_ready_state_enter(void *object)
948 struct scic_sds_remote_device *sci_dev = object;
949 struct scic_sds_controller *scic = sci_dev->owning_port->owning_controller;
950 struct domain_device *dev = sci_dev_to_domain(sci_dev);
952 scic->remote_device_sequence[sci_dev->rnc.remote_node_index]++;
954 if (dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_SATA)) {
955 sci_base_state_machine_change_state(&sci_dev->state_machine,
956 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE);
957 } else if (dev_is_expander(dev)) {
958 sci_base_state_machine_change_state(&sci_dev->state_machine,
959 SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE);
961 isci_remote_device_ready(scic->ihost, sci_dev_to_idev(sci_dev));
964 static void scic_sds_remote_device_ready_state_exit(void *object)
966 struct scic_sds_remote_device *sci_dev = object;
967 struct domain_device *dev = sci_dev_to_domain(sci_dev);
969 if (dev->dev_type == SAS_END_DEV) {
970 struct scic_sds_controller *scic = sci_dev->owning_port->owning_controller;
971 struct isci_remote_device *idev = sci_dev_to_idev(sci_dev);
973 isci_remote_device_not_ready(scic->ihost, idev,
974 SCIC_REMOTE_DEVICE_NOT_READY_STOP_REQUESTED);
978 static void scic_sds_remote_device_resetting_state_enter(void *object)
980 struct scic_sds_remote_device *sci_dev = object;
982 scic_sds_remote_node_context_suspend(
983 &sci_dev->rnc, SCI_SOFTWARE_SUSPENSION, NULL, NULL);
986 static void scic_sds_remote_device_resetting_state_exit(void *object)
988 struct scic_sds_remote_device *sci_dev = object;
990 scic_sds_remote_node_context_resume(&sci_dev->rnc, NULL, NULL);
993 static void scic_sds_stp_remote_device_ready_idle_substate_enter(void *object)
995 struct scic_sds_remote_device *sci_dev = object;
997 sci_dev->working_request = NULL;
998 if (scic_sds_remote_node_context_is_ready(&sci_dev->rnc)) {
1000 * Since the RNC is ready, it's alright to finish completion
1001 * processing (e.g. signal the remote device is ready). */
1002 scic_sds_stp_remote_device_ready_idle_substate_resume_complete_handler(sci_dev);
1004 scic_sds_remote_node_context_resume(&sci_dev->rnc,
1005 scic_sds_stp_remote_device_ready_idle_substate_resume_complete_handler,
1010 static void scic_sds_stp_remote_device_ready_cmd_substate_enter(void *object)
1012 struct scic_sds_remote_device *sci_dev = object;
1013 struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev);
1015 BUG_ON(sci_dev->working_request == NULL);
1017 isci_remote_device_not_ready(scic->ihost, sci_dev_to_idev(sci_dev),
1018 SCIC_REMOTE_DEVICE_NOT_READY_SATA_REQUEST_STARTED);
1021 static void scic_sds_stp_remote_device_ready_ncq_error_substate_enter(void *object)
1023 struct scic_sds_remote_device *sci_dev = object;
1024 struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev);
1025 struct isci_remote_device *idev = sci_dev_to_idev(sci_dev);
1027 if (sci_dev->not_ready_reason == SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED)
1028 isci_remote_device_not_ready(scic->ihost, idev,
1029 sci_dev->not_ready_reason);
1032 static void scic_sds_smp_remote_device_ready_idle_substate_enter(void *object)
1034 struct scic_sds_remote_device *sci_dev = object;
1035 struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev);
1037 isci_remote_device_ready(scic->ihost, sci_dev_to_idev(sci_dev));
1040 static void scic_sds_smp_remote_device_ready_cmd_substate_enter(void *object)
1042 struct scic_sds_remote_device *sci_dev = object;
1043 struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev);
1045 BUG_ON(sci_dev->working_request == NULL);
1047 isci_remote_device_not_ready(scic->ihost, sci_dev_to_idev(sci_dev),
1048 SCIC_REMOTE_DEVICE_NOT_READY_SMP_REQUEST_STARTED);
1051 static void scic_sds_smp_remote_device_ready_cmd_substate_exit(void *object)
1053 struct scic_sds_remote_device *sci_dev = object;
1055 sci_dev->working_request = NULL;
1058 static const struct sci_base_state scic_sds_remote_device_state_table[] = {
1059 [SCI_BASE_REMOTE_DEVICE_STATE_INITIAL] = {
1060 .enter_state = scic_sds_remote_device_initial_state_enter,
1062 [SCI_BASE_REMOTE_DEVICE_STATE_STOPPED] = {
1063 .enter_state = scic_sds_remote_device_stopped_state_enter,
1065 [SCI_BASE_REMOTE_DEVICE_STATE_STARTING] = {
1066 .enter_state = scic_sds_remote_device_starting_state_enter,
1068 [SCI_BASE_REMOTE_DEVICE_STATE_READY] = {
1069 .enter_state = scic_sds_remote_device_ready_state_enter,
1070 .exit_state = scic_sds_remote_device_ready_state_exit
1072 [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE] = {
1073 .enter_state = scic_sds_stp_remote_device_ready_idle_substate_enter,
1075 [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD] = {
1076 .enter_state = scic_sds_stp_remote_device_ready_cmd_substate_enter,
1078 [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ] = { },
1079 [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR] = {
1080 .enter_state = scic_sds_stp_remote_device_ready_ncq_error_substate_enter,
1082 [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET] = { },
1083 [SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE] = {
1084 .enter_state = scic_sds_smp_remote_device_ready_idle_substate_enter,
1086 [SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD] = {
1087 .enter_state = scic_sds_smp_remote_device_ready_cmd_substate_enter,
1088 .exit_state = scic_sds_smp_remote_device_ready_cmd_substate_exit,
1090 [SCI_BASE_REMOTE_DEVICE_STATE_STOPPING] = { },
1091 [SCI_BASE_REMOTE_DEVICE_STATE_FAILED] = { },
1092 [SCI_BASE_REMOTE_DEVICE_STATE_RESETTING] = {
1093 .enter_state = scic_sds_remote_device_resetting_state_enter,
1094 .exit_state = scic_sds_remote_device_resetting_state_exit
1096 [SCI_BASE_REMOTE_DEVICE_STATE_FINAL] = { },
1100 * scic_remote_device_construct() - common construction
1101 * @sci_port: SAS/SATA port through which this device is accessed.
1102 * @sci_dev: remote device to construct
1104 * This routine just performs benign initialization and does not
1105 * allocate the remote_node_context which is left to
1106 * scic_remote_device_[de]a_construct(). scic_remote_device_destruct()
1107 * frees the remote_node_context(s) for the device.
1109 static void scic_remote_device_construct(struct scic_sds_port *sci_port,
1110 struct scic_sds_remote_device *sci_dev)
1112 sci_dev->owning_port = sci_port;
1113 sci_dev->started_request_count = 0;
1115 sci_base_state_machine_construct(
1116 &sci_dev->state_machine,
1118 scic_sds_remote_device_state_table,
1119 SCI_BASE_REMOTE_DEVICE_STATE_INITIAL
1122 sci_base_state_machine_start(
1123 &sci_dev->state_machine
1126 scic_sds_remote_node_context_construct(&sci_dev->rnc,
1127 SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX);
1131 * scic_remote_device_da_construct() - construct direct attached device.
1133 * The information (e.g. IAF, Signature FIS, etc.) necessary to build
1134 * the device is known to the SCI Core since it is contained in the
1135 * scic_phy object. Remote node context(s) is/are a global resource
1136 * allocated by this routine, freed by scic_remote_device_destruct().
1139 * SCI_FAILURE_DEVICE_EXISTS - device has already been constructed.
1140 * SCI_FAILURE_UNSUPPORTED_PROTOCOL - e.g. sas device attached to
1141 * sata-only controller instance.
1142 * SCI_FAILURE_INSUFFICIENT_RESOURCES - remote node contexts exhausted.
1144 static enum sci_status scic_remote_device_da_construct(struct scic_sds_port *sci_port,
1145 struct scic_sds_remote_device *sci_dev)
1147 enum sci_status status;
1148 struct domain_device *dev = sci_dev_to_domain(sci_dev);
1150 scic_remote_device_construct(sci_port, sci_dev);
1153 * This information is request to determine how many remote node context
1154 * entries will be needed to store the remote node.
1156 sci_dev->is_direct_attached = true;
1157 status = scic_sds_controller_allocate_remote_node_context(sci_port->owning_controller,
1159 &sci_dev->rnc.remote_node_index);
1161 if (status != SCI_SUCCESS)
1164 if (dev->dev_type == SAS_END_DEV || dev->dev_type == SATA_DEV ||
1165 (dev->tproto & SAS_PROTOCOL_STP) || dev_is_expander(dev))
1168 return SCI_FAILURE_UNSUPPORTED_PROTOCOL;
1170 sci_dev->connection_rate = scic_sds_port_get_max_allowed_speed(sci_port);
1172 /* / @todo Should I assign the port width by reading all of the phys on the port? */
1173 sci_dev->device_port_width = 1;
1179 * scic_remote_device_ea_construct() - construct expander attached device
1181 * Remote node context(s) is/are a global resource allocated by this
1182 * routine, freed by scic_remote_device_destruct().
1185 * SCI_FAILURE_DEVICE_EXISTS - device has already been constructed.
1186 * SCI_FAILURE_UNSUPPORTED_PROTOCOL - e.g. sas device attached to
1187 * sata-only controller instance.
1188 * SCI_FAILURE_INSUFFICIENT_RESOURCES - remote node contexts exhausted.
1190 static enum sci_status scic_remote_device_ea_construct(struct scic_sds_port *sci_port,
1191 struct scic_sds_remote_device *sci_dev)
1193 struct domain_device *dev = sci_dev_to_domain(sci_dev);
1194 enum sci_status status;
1196 scic_remote_device_construct(sci_port, sci_dev);
1198 status = scic_sds_controller_allocate_remote_node_context(sci_port->owning_controller,
1200 &sci_dev->rnc.remote_node_index);
1201 if (status != SCI_SUCCESS)
1204 if (dev->dev_type == SAS_END_DEV || dev->dev_type == SATA_DEV ||
1205 (dev->tproto & SAS_PROTOCOL_STP) || dev_is_expander(dev))
1208 return SCI_FAILURE_UNSUPPORTED_PROTOCOL;
1211 * For SAS-2 the physical link rate is actually a logical link
1212 * rate that incorporates multiplexing. The SCU doesn't
1213 * incorporate multiplexing and for the purposes of the
1214 * connection the logical link rate is that same as the
1215 * physical. Furthermore, the SAS-2 and SAS-1.1 fields overlay
1216 * one another, so this code works for both situations. */
1217 sci_dev->connection_rate = min_t(u16, scic_sds_port_get_max_allowed_speed(sci_port),
1220 /* / @todo Should I assign the port width by reading all of the phys on the port? */
1221 sci_dev->device_port_width = 1;
1227 * scic_remote_device_start() - This method will start the supplied remote
1228 * device. This method enables normal IO requests to flow through to the
1230 * @remote_device: This parameter specifies the device to be started.
1231 * @timeout: This parameter specifies the number of milliseconds in which the
1232 * start operation should complete.
1234 * An indication of whether the device was successfully started. SCI_SUCCESS
1235 * This value is returned if the device was successfully started.
1236 * SCI_FAILURE_INVALID_PHY This value is returned if the user attempts to start
1237 * the device when there have been no phys added to it.
1239 static enum sci_status scic_remote_device_start(struct scic_sds_remote_device *sci_dev,
1242 struct sci_base_state_machine *sm = &sci_dev->state_machine;
1243 enum scic_sds_remote_device_states state = sm->current_state_id;
1244 enum sci_status status;
1246 if (state != SCI_BASE_REMOTE_DEVICE_STATE_STOPPED) {
1247 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
1249 return SCI_FAILURE_INVALID_STATE;
1252 status = scic_sds_remote_node_context_resume(&sci_dev->rnc,
1253 remote_device_resume_done,
1255 if (status != SCI_SUCCESS)
1258 sci_base_state_machine_change_state(sm, SCI_BASE_REMOTE_DEVICE_STATE_STARTING);
1263 static enum sci_status isci_remote_device_construct(struct isci_port *iport,
1264 struct isci_remote_device *idev)
1266 struct scic_sds_port *sci_port = iport->sci_port_handle;
1267 struct isci_host *ihost = iport->isci_host;
1268 struct domain_device *dev = idev->domain_dev;
1269 enum sci_status status;
1271 if (dev->parent && dev_is_expander(dev->parent))
1272 status = scic_remote_device_ea_construct(sci_port, &idev->sci);
1274 status = scic_remote_device_da_construct(sci_port, &idev->sci);
1276 if (status != SCI_SUCCESS) {
1277 dev_dbg(&ihost->pdev->dev, "%s: construct failed: %d\n",
1283 /* start the device. */
1284 status = scic_remote_device_start(&idev->sci, ISCI_REMOTE_DEVICE_START_TIMEOUT);
1286 if (status != SCI_SUCCESS)
1287 dev_warn(&ihost->pdev->dev, "remote device start failed: %d\n",
1293 void isci_remote_device_nuke_requests(struct isci_host *ihost, struct isci_remote_device *idev)
1295 DECLARE_COMPLETION_ONSTACK(aborted_task_completion);
1297 dev_dbg(&ihost->pdev->dev,
1298 "%s: idev = %p\n", __func__, idev);
1300 /* Cleanup all requests pending for this device. */
1301 isci_terminate_pending_requests(ihost, idev, terminating);
1303 dev_dbg(&ihost->pdev->dev,
1304 "%s: idev = %p, done\n", __func__, idev);
1308 * This function builds the isci_remote_device when a libsas dev_found message
1310 * @isci_host: This parameter specifies the isci host object.
1311 * @port: This parameter specifies the isci_port conected to this device.
1313 * pointer to new isci_remote_device.
1315 static struct isci_remote_device *
1316 isci_remote_device_alloc(struct isci_host *ihost, struct isci_port *iport)
1318 struct isci_remote_device *idev;
1321 for (i = 0; i < SCI_MAX_REMOTE_DEVICES; i++) {
1322 idev = &ihost->devices[i];
1323 if (!test_and_set_bit(IDEV_ALLOCATED, &idev->flags))
1327 if (i >= SCI_MAX_REMOTE_DEVICES) {
1328 dev_warn(&ihost->pdev->dev, "%s: failed\n", __func__);
1332 if (WARN_ONCE(!list_empty(&idev->reqs_in_process), "found requests in process\n"))
1335 if (WARN_ONCE(!list_empty(&idev->node), "found non-idle remote device\n"))
1338 isci_remote_device_change_state(idev, isci_freed);
1344 * isci_remote_device_stop() - This function is called internally to stop the
1346 * @isci_host: This parameter specifies the isci host object.
1347 * @isci_device: This parameter specifies the remote device.
1349 * The status of the scic request to stop.
1351 enum sci_status isci_remote_device_stop(struct isci_host *ihost, struct isci_remote_device *idev)
1353 enum sci_status status;
1354 unsigned long flags;
1356 dev_dbg(&ihost->pdev->dev,
1357 "%s: isci_device = %p\n", __func__, idev);
1359 isci_remote_device_change_state(idev, isci_stopping);
1361 /* Kill all outstanding requests. */
1362 isci_remote_device_nuke_requests(ihost, idev);
1364 set_bit(IDEV_STOP_PENDING, &idev->flags);
1366 spin_lock_irqsave(&ihost->scic_lock, flags);
1367 status = scic_remote_device_stop(&idev->sci, 50);
1368 spin_unlock_irqrestore(&ihost->scic_lock, flags);
1370 /* Wait for the stop complete callback. */
1371 if (status == SCI_SUCCESS) {
1372 wait_for_device_stop(ihost, idev);
1373 clear_bit(IDEV_ALLOCATED, &idev->flags);
1376 dev_dbg(&ihost->pdev->dev,
1377 "%s: idev = %p - after completion wait\n",
1384 * isci_remote_device_gone() - This function is called by libsas when a domain
1385 * device is removed.
1386 * @domain_device: This parameter specifies the libsas domain device.
1389 void isci_remote_device_gone(struct domain_device *dev)
1391 struct isci_host *ihost = dev_to_ihost(dev);
1392 struct isci_remote_device *idev = dev->lldd_dev;
1394 dev_dbg(&ihost->pdev->dev,
1395 "%s: domain_device = %p, isci_device = %p, isci_port = %p\n",
1396 __func__, dev, idev, idev->isci_port);
1398 isci_remote_device_stop(ihost, idev);
1403 * isci_remote_device_found() - This function is called by libsas when a remote
1404 * device is discovered. A remote device object is created and started. the
1405 * function then sleeps until the sci core device started message is
1407 * @domain_device: This parameter specifies the libsas domain device.
1409 * status, zero indicates success.
1411 int isci_remote_device_found(struct domain_device *domain_dev)
1413 struct isci_host *isci_host = dev_to_ihost(domain_dev);
1414 struct isci_port *isci_port;
1415 struct isci_phy *isci_phy;
1416 struct asd_sas_port *sas_port;
1417 struct asd_sas_phy *sas_phy;
1418 struct isci_remote_device *isci_device;
1419 enum sci_status status;
1421 dev_dbg(&isci_host->pdev->dev,
1422 "%s: domain_device = %p\n", __func__, domain_dev);
1424 wait_for_start(isci_host);
1426 sas_port = domain_dev->port;
1427 sas_phy = list_first_entry(&sas_port->phy_list, struct asd_sas_phy,
1429 isci_phy = to_isci_phy(sas_phy);
1430 isci_port = isci_phy->isci_port;
1432 /* we are being called for a device on this port,
1433 * so it has to come up eventually
1435 wait_for_completion(&isci_port->start_complete);
1437 if ((isci_stopping == isci_port_get_state(isci_port)) ||
1438 (isci_stopped == isci_port_get_state(isci_port)))
1441 isci_device = isci_remote_device_alloc(isci_host, isci_port);
1445 INIT_LIST_HEAD(&isci_device->node);
1446 domain_dev->lldd_dev = isci_device;
1447 isci_device->domain_dev = domain_dev;
1448 isci_device->isci_port = isci_port;
1449 isci_remote_device_change_state(isci_device, isci_starting);
1452 spin_lock_irq(&isci_host->scic_lock);
1453 list_add_tail(&isci_device->node, &isci_port->remote_dev_list);
1455 set_bit(IDEV_START_PENDING, &isci_device->flags);
1456 status = isci_remote_device_construct(isci_port, isci_device);
1457 spin_unlock_irq(&isci_host->scic_lock);
1459 dev_dbg(&isci_host->pdev->dev,
1460 "%s: isci_device = %p\n",
1461 __func__, isci_device);
1463 if (status != SCI_SUCCESS) {
1465 spin_lock_irq(&isci_host->scic_lock);
1466 isci_remote_device_deconstruct(
1470 spin_unlock_irq(&isci_host->scic_lock);
1474 /* wait for the device ready callback. */
1475 wait_for_device_start(isci_host, isci_device);
1480 * isci_device_is_reset_pending() - This function will check if there is any
1481 * pending reset condition on the device.
1482 * @request: This parameter is the isci_device object.
1484 * true if there is a reset pending for the device.
1486 bool isci_device_is_reset_pending(
1487 struct isci_host *isci_host,
1488 struct isci_remote_device *isci_device)
1490 struct isci_request *isci_request;
1491 struct isci_request *tmp_req;
1492 bool reset_is_pending = false;
1493 unsigned long flags;
1495 dev_dbg(&isci_host->pdev->dev,
1496 "%s: isci_device = %p\n", __func__, isci_device);
1498 spin_lock_irqsave(&isci_host->scic_lock, flags);
1500 /* Check for reset on all pending requests. */
1501 list_for_each_entry_safe(isci_request, tmp_req,
1502 &isci_device->reqs_in_process, dev_node) {
1503 dev_dbg(&isci_host->pdev->dev,
1504 "%s: isci_device = %p request = %p\n",
1505 __func__, isci_device, isci_request);
1507 if (isci_request->ttype == io_task) {
1508 struct sas_task *task = isci_request_access_task(
1511 spin_lock(&task->task_state_lock);
1512 if (task->task_state_flags & SAS_TASK_NEED_DEV_RESET)
1513 reset_is_pending = true;
1514 spin_unlock(&task->task_state_lock);
1518 spin_unlock_irqrestore(&isci_host->scic_lock, flags);
1520 dev_dbg(&isci_host->pdev->dev,
1521 "%s: isci_device = %p reset_is_pending = %d\n",
1522 __func__, isci_device, reset_is_pending);
1524 return reset_is_pending;
1528 * isci_device_clear_reset_pending() - This function will clear if any pending
1529 * reset condition flags on the device.
1530 * @request: This parameter is the isci_device object.
1532 * true if there is a reset pending for the device.
1534 void isci_device_clear_reset_pending(struct isci_host *ihost, struct isci_remote_device *idev)
1536 struct isci_request *isci_request;
1537 struct isci_request *tmp_req;
1538 unsigned long flags = 0;
1540 dev_dbg(&ihost->pdev->dev, "%s: idev=%p, ihost=%p\n",
1541 __func__, idev, ihost);
1543 spin_lock_irqsave(&ihost->scic_lock, flags);
1545 /* Clear reset pending on all pending requests. */
1546 list_for_each_entry_safe(isci_request, tmp_req,
1547 &idev->reqs_in_process, dev_node) {
1548 dev_dbg(&ihost->pdev->dev, "%s: idev = %p request = %p\n",
1549 __func__, idev, isci_request);
1551 if (isci_request->ttype == io_task) {
1553 unsigned long flags2;
1554 struct sas_task *task = isci_request_access_task(
1557 spin_lock_irqsave(&task->task_state_lock, flags2);
1558 task->task_state_flags &= ~SAS_TASK_NEED_DEV_RESET;
1559 spin_unlock_irqrestore(&task->task_state_lock, flags2);
1562 spin_unlock_irqrestore(&ihost->scic_lock, flags);