isci: unify isci_remote_device and scic_sds_remote_device
[linux-2.6.git] / drivers / scsi / isci / remote_device.c
1 /*
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.
4  *
5  * GPL LICENSE SUMMARY
6  *
7  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
8  *
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.
12  *
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.
17  *
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.
23  *
24  * BSD LICENSE
25  *
26  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
27  * All rights reserved.
28  *
29  * Redistribution and use in source and binary forms, with or without
30  * modification, are permitted provided that the following conditions
31  * are met:
32  *
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
38  *     distribution.
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.
42  *
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.
54  */
55 #include <scsi/sas.h>
56 #include "isci.h"
57 #include "port.h"
58 #include "remote_device.h"
59 #include "request.h"
60 #include "remote_node_context.h"
61 #include "scu_event_codes.h"
62 #include "task.h"
63
64 /**
65  * isci_remote_device_not_ready() - This function is called by the scic when
66  *    the remote device is not ready. We mark the isci device as ready (not
67  *    "ready_for_io") and signal the waiting proccess.
68  * @isci_host: This parameter specifies the isci host object.
69  * @isci_device: This parameter specifies the remote device
70  *
71  * scic_lock is held on entrance to this function.
72  */
73 static void isci_remote_device_not_ready(struct isci_host *ihost,
74                                   struct isci_remote_device *idev, u32 reason)
75 {
76         struct isci_request * ireq;
77
78         dev_dbg(&ihost->pdev->dev,
79                 "%s: isci_device = %p\n", __func__, idev);
80
81         switch (reason) {
82         case SCIC_REMOTE_DEVICE_NOT_READY_STOP_REQUESTED:
83                 set_bit(IDEV_GONE, &idev->flags);
84                 break;
85         case SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED:
86                 set_bit(IDEV_IO_NCQERROR, &idev->flags);
87
88                 /* Kill all outstanding requests for the device. */
89                 list_for_each_entry(ireq, &idev->reqs_in_process, dev_node) {
90
91                         dev_dbg(&ihost->pdev->dev,
92                                 "%s: isci_device = %p request = %p\n",
93                                 __func__, idev, ireq);
94
95                         scic_controller_terminate_request(&ihost->sci,
96                                                           idev,
97                                                           ireq);
98                 }
99                 /* Fall through into the default case... */
100         default:
101                 clear_bit(IDEV_IO_READY, &idev->flags);
102                 break;
103         }
104 }
105
106 /**
107  * isci_remote_device_ready() - This function is called by the scic when the
108  *    remote device is ready. We mark the isci device as ready and signal the
109  *    waiting proccess.
110  * @ihost: our valid isci_host
111  * @idev: remote device
112  *
113  */
114 static void isci_remote_device_ready(struct isci_host *ihost, struct isci_remote_device *idev)
115 {
116         dev_dbg(&ihost->pdev->dev,
117                 "%s: idev = %p\n", __func__, idev);
118
119         clear_bit(IDEV_IO_NCQERROR, &idev->flags);
120         set_bit(IDEV_IO_READY, &idev->flags);
121         if (test_and_clear_bit(IDEV_START_PENDING, &idev->flags))
122                 wake_up(&ihost->eventq);
123 }
124
125 /* called once the remote node context is ready to be freed.
126  * The remote device can now report that its stop operation is complete. none
127  */
128 static void rnc_destruct_done(void *_dev)
129 {
130         struct isci_remote_device *idev = _dev;
131
132         BUG_ON(idev->started_request_count != 0);
133         sci_change_state(&idev->sm, SCI_DEV_STOPPED);
134 }
135
136 static enum sci_status scic_sds_remote_device_terminate_requests(struct isci_remote_device *idev)
137 {
138         struct scic_sds_controller *scic = idev->owning_port->owning_controller;
139         struct isci_host *ihost = scic_to_ihost(scic);
140         enum sci_status status  = SCI_SUCCESS;
141         u32 i;
142
143         for (i = 0; i < SCI_MAX_IO_REQUESTS; i++) {
144                 struct isci_request *ireq = ihost->reqs[i];
145                 enum sci_status s;
146
147                 if (!test_bit(IREQ_ACTIVE, &ireq->flags) ||
148                     ireq->target_device != idev)
149                         continue;
150
151                 s = scic_controller_terminate_request(scic, idev, ireq);
152                 if (s != SCI_SUCCESS)
153                         status = s;
154         }
155
156         return status;
157 }
158
159 enum sci_status scic_remote_device_stop(struct isci_remote_device *idev,
160                                         u32 timeout)
161 {
162         struct sci_base_state_machine *sm = &idev->sm;
163         enum scic_sds_remote_device_states state = sm->current_state_id;
164
165         switch (state) {
166         case SCI_DEV_INITIAL:
167         case SCI_DEV_FAILED:
168         case SCI_DEV_FINAL:
169         default:
170                 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
171                          __func__, state);
172                 return SCI_FAILURE_INVALID_STATE;
173         case SCI_DEV_STOPPED:
174                 return SCI_SUCCESS;
175         case SCI_DEV_STARTING:
176                 /* device not started so there had better be no requests */
177                 BUG_ON(idev->started_request_count != 0);
178                 scic_sds_remote_node_context_destruct(&idev->rnc,
179                                                       rnc_destruct_done, idev);
180                 /* Transition to the stopping state and wait for the
181                  * remote node to complete being posted and invalidated.
182                  */
183                 sci_change_state(sm, SCI_DEV_STOPPING);
184                 return SCI_SUCCESS;
185         case SCI_DEV_READY:
186         case SCI_STP_DEV_IDLE:
187         case SCI_STP_DEV_CMD:
188         case SCI_STP_DEV_NCQ:
189         case SCI_STP_DEV_NCQ_ERROR:
190         case SCI_STP_DEV_AWAIT_RESET:
191         case SCI_SMP_DEV_IDLE:
192         case SCI_SMP_DEV_CMD:
193                 sci_change_state(sm, SCI_DEV_STOPPING);
194                 if (idev->started_request_count == 0) {
195                         scic_sds_remote_node_context_destruct(&idev->rnc,
196                                                               rnc_destruct_done, idev);
197                         return SCI_SUCCESS;
198                 } else
199                         return scic_sds_remote_device_terminate_requests(idev);
200                 break;
201         case SCI_DEV_STOPPING:
202                 /* All requests should have been terminated, but if there is an
203                  * attempt to stop a device already in the stopping state, then
204                  * try again to terminate.
205                  */
206                 return scic_sds_remote_device_terminate_requests(idev);
207         case SCI_DEV_RESETTING:
208                 sci_change_state(sm, SCI_DEV_STOPPING);
209                 return SCI_SUCCESS;
210         }
211 }
212
213 enum sci_status scic_remote_device_reset(struct isci_remote_device *idev)
214 {
215         struct sci_base_state_machine *sm = &idev->sm;
216         enum scic_sds_remote_device_states state = sm->current_state_id;
217
218         switch (state) {
219         case SCI_DEV_INITIAL:
220         case SCI_DEV_STOPPED:
221         case SCI_DEV_STARTING:
222         case SCI_SMP_DEV_IDLE:
223         case SCI_SMP_DEV_CMD:
224         case SCI_DEV_STOPPING:
225         case SCI_DEV_FAILED:
226         case SCI_DEV_RESETTING:
227         case SCI_DEV_FINAL:
228         default:
229                 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
230                          __func__, state);
231                 return SCI_FAILURE_INVALID_STATE;
232         case SCI_DEV_READY:
233         case SCI_STP_DEV_IDLE:
234         case SCI_STP_DEV_CMD:
235         case SCI_STP_DEV_NCQ:
236         case SCI_STP_DEV_NCQ_ERROR:
237         case SCI_STP_DEV_AWAIT_RESET:
238                 sci_change_state(sm, SCI_DEV_RESETTING);
239                 return SCI_SUCCESS;
240         }
241 }
242
243 enum sci_status scic_remote_device_reset_complete(struct isci_remote_device *idev)
244 {
245         struct sci_base_state_machine *sm = &idev->sm;
246         enum scic_sds_remote_device_states state = sm->current_state_id;
247
248         if (state != SCI_DEV_RESETTING) {
249                 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
250                          __func__, state);
251                 return SCI_FAILURE_INVALID_STATE;
252         }
253
254         sci_change_state(sm, SCI_DEV_READY);
255         return SCI_SUCCESS;
256 }
257
258 enum sci_status scic_sds_remote_device_suspend(struct isci_remote_device *idev,
259                                                u32 suspend_type)
260 {
261         struct sci_base_state_machine *sm = &idev->sm;
262         enum scic_sds_remote_device_states state = sm->current_state_id;
263
264         if (state != SCI_STP_DEV_CMD) {
265                 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
266                          __func__, state);
267                 return SCI_FAILURE_INVALID_STATE;
268         }
269
270         return scic_sds_remote_node_context_suspend(&idev->rnc,
271                                                     suspend_type, NULL, NULL);
272 }
273
274 enum sci_status scic_sds_remote_device_frame_handler(struct isci_remote_device *idev,
275                                                      u32 frame_index)
276 {
277         struct sci_base_state_machine *sm = &idev->sm;
278         enum scic_sds_remote_device_states state = sm->current_state_id;
279         struct scic_sds_controller *scic = idev->owning_port->owning_controller;
280         enum sci_status status;
281
282         switch (state) {
283         case SCI_DEV_INITIAL:
284         case SCI_DEV_STOPPED:
285         case SCI_DEV_STARTING:
286         case SCI_STP_DEV_IDLE:
287         case SCI_SMP_DEV_IDLE:
288         case SCI_DEV_FINAL:
289         default:
290                 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
291                          __func__, state);
292                 /* Return the frame back to the controller */
293                 scic_sds_controller_release_frame(scic, frame_index);
294                 return SCI_FAILURE_INVALID_STATE;
295         case SCI_DEV_READY:
296         case SCI_STP_DEV_NCQ_ERROR:
297         case SCI_STP_DEV_AWAIT_RESET:
298         case SCI_DEV_STOPPING:
299         case SCI_DEV_FAILED:
300         case SCI_DEV_RESETTING: {
301                 struct isci_request *ireq;
302                 struct ssp_frame_hdr hdr;
303                 void *frame_header;
304                 ssize_t word_cnt;
305
306                 status = scic_sds_unsolicited_frame_control_get_header(&scic->uf_control,
307                                                                        frame_index,
308                                                                        &frame_header);
309                 if (status != SCI_SUCCESS)
310                         return status;
311
312                 word_cnt = sizeof(hdr) / sizeof(u32);
313                 sci_swab32_cpy(&hdr, frame_header, word_cnt);
314
315                 ireq = scic_request_by_tag(scic, be16_to_cpu(hdr.tag));
316                 if (ireq && ireq->target_device == idev) {
317                         /* The IO request is now in charge of releasing the frame */
318                         status = scic_sds_io_request_frame_handler(ireq, frame_index);
319                 } else {
320                         /* We could not map this tag to a valid IO
321                          * request Just toss the frame and continue
322                          */
323                         scic_sds_controller_release_frame(scic, frame_index);
324                 }
325                 break;
326         }
327         case SCI_STP_DEV_NCQ: {
328                 struct dev_to_host_fis *hdr;
329
330                 status = scic_sds_unsolicited_frame_control_get_header(&scic->uf_control,
331                                                                        frame_index,
332                                                                        (void **)&hdr);
333                 if (status != SCI_SUCCESS)
334                         return status;
335
336                 if (hdr->fis_type == FIS_SETDEVBITS &&
337                     (hdr->status & ATA_ERR)) {
338                         idev->not_ready_reason = SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED;
339
340                         /* TODO Check sactive and complete associated IO if any. */
341                         sci_change_state(sm, SCI_STP_DEV_NCQ_ERROR);
342                 } else if (hdr->fis_type == FIS_REGD2H &&
343                            (hdr->status & ATA_ERR)) {
344                         /*
345                          * Some devices return D2H FIS when an NCQ error is detected.
346                          * Treat this like an SDB error FIS ready reason.
347                          */
348                         idev->not_ready_reason = SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED;
349                         sci_change_state(&idev->sm, SCI_STP_DEV_NCQ_ERROR);
350                 } else
351                         status = SCI_FAILURE;
352
353                 scic_sds_controller_release_frame(scic, frame_index);
354                 break;
355         }
356         case SCI_STP_DEV_CMD:
357         case SCI_SMP_DEV_CMD:
358                 /* The device does not process any UF received from the hardware while
359                  * in this state.  All unsolicited frames are forwarded to the io request
360                  * object.
361                  */
362                 status = scic_sds_io_request_frame_handler(idev->working_request, frame_index);
363                 break;
364         }
365
366         return status;
367 }
368
369 static bool is_remote_device_ready(struct isci_remote_device *idev)
370 {
371
372         struct sci_base_state_machine *sm = &idev->sm;
373         enum scic_sds_remote_device_states state = sm->current_state_id;
374
375         switch (state) {
376         case SCI_DEV_READY:
377         case SCI_STP_DEV_IDLE:
378         case SCI_STP_DEV_CMD:
379         case SCI_STP_DEV_NCQ:
380         case SCI_STP_DEV_NCQ_ERROR:
381         case SCI_STP_DEV_AWAIT_RESET:
382         case SCI_SMP_DEV_IDLE:
383         case SCI_SMP_DEV_CMD:
384                 return true;
385         default:
386                 return false;
387         }
388 }
389
390 enum sci_status scic_sds_remote_device_event_handler(struct isci_remote_device *idev,
391                                                      u32 event_code)
392 {
393         struct sci_base_state_machine *sm = &idev->sm;
394         enum scic_sds_remote_device_states state = sm->current_state_id;
395         enum sci_status status;
396
397         switch (scu_get_event_type(event_code)) {
398         case SCU_EVENT_TYPE_RNC_OPS_MISC:
399         case SCU_EVENT_TYPE_RNC_SUSPEND_TX:
400         case SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX:
401                 status = scic_sds_remote_node_context_event_handler(&idev->rnc, event_code);
402                 break;
403         case SCU_EVENT_TYPE_PTX_SCHEDULE_EVENT:
404                 if (scu_get_event_code(event_code) == SCU_EVENT_IT_NEXUS_TIMEOUT) {
405                         status = SCI_SUCCESS;
406
407                         /* Suspend the associated RNC */
408                         scic_sds_remote_node_context_suspend(&idev->rnc,
409                                                               SCI_SOFTWARE_SUSPENSION,
410                                                               NULL, NULL);
411
412                         dev_dbg(scirdev_to_dev(idev),
413                                 "%s: device: %p event code: %x: %s\n",
414                                 __func__, idev, event_code,
415                                 is_remote_device_ready(idev)
416                                 ? "I_T_Nexus_Timeout event"
417                                 : "I_T_Nexus_Timeout event in wrong state");
418
419                         break;
420                 }
421         /* Else, fall through and treat as unhandled... */
422         default:
423                 dev_dbg(scirdev_to_dev(idev),
424                         "%s: device: %p event code: %x: %s\n",
425                         __func__, idev, event_code,
426                         is_remote_device_ready(idev)
427                         ? "unexpected event"
428                         : "unexpected event in wrong state");
429                 status = SCI_FAILURE_INVALID_STATE;
430                 break;
431         }
432
433         if (status != SCI_SUCCESS)
434                 return status;
435
436         if (state == SCI_STP_DEV_IDLE) {
437
438                 /* We pick up suspension events to handle specifically to this
439                  * state. We resume the RNC right away.
440                  */
441                 if (scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX ||
442                     scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX)
443                         status = scic_sds_remote_node_context_resume(&idev->rnc, NULL, NULL);
444         }
445
446         return status;
447 }
448
449 static void scic_sds_remote_device_start_request(struct isci_remote_device *idev,
450                                                  struct isci_request *ireq,
451                                                  enum sci_status status)
452 {
453         struct isci_port *iport = idev->owning_port;
454
455         /* cleanup requests that failed after starting on the port */
456         if (status != SCI_SUCCESS)
457                 scic_sds_port_complete_io(iport, idev, ireq);
458         else {
459                 kref_get(&idev->kref);
460                 scic_sds_remote_device_increment_request_count(idev);
461         }
462 }
463
464 enum sci_status scic_sds_remote_device_start_io(struct scic_sds_controller *scic,
465                                                 struct isci_remote_device *idev,
466                                                 struct isci_request *ireq)
467 {
468         struct sci_base_state_machine *sm = &idev->sm;
469         enum scic_sds_remote_device_states state = sm->current_state_id;
470         struct isci_port *iport = idev->owning_port;
471         enum sci_status status;
472
473         switch (state) {
474         case SCI_DEV_INITIAL:
475         case SCI_DEV_STOPPED:
476         case SCI_DEV_STARTING:
477         case SCI_STP_DEV_NCQ_ERROR:
478         case SCI_DEV_STOPPING:
479         case SCI_DEV_FAILED:
480         case SCI_DEV_RESETTING:
481         case SCI_DEV_FINAL:
482         default:
483                 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
484                          __func__, state);
485                 return SCI_FAILURE_INVALID_STATE;
486         case SCI_DEV_READY:
487                 /* attempt to start an io request for this device object. The remote
488                  * device object will issue the start request for the io and if
489                  * successful it will start the request for the port object then
490                  * increment its own request count.
491                  */
492                 status = scic_sds_port_start_io(iport, idev, ireq);
493                 if (status != SCI_SUCCESS)
494                         return status;
495
496                 status = scic_sds_remote_node_context_start_io(&idev->rnc, ireq);
497                 if (status != SCI_SUCCESS)
498                         break;
499
500                 status = scic_sds_request_start(ireq);
501                 break;
502         case SCI_STP_DEV_IDLE: {
503                 /* handle the start io operation for a sata device that is in
504                  * the command idle state. - Evalute the type of IO request to
505                  * be started - If its an NCQ request change to NCQ substate -
506                  * If its any other command change to the CMD substate
507                  *
508                  * If this is a softreset we may want to have a different
509                  * substate.
510                  */
511                 enum scic_sds_remote_device_states new_state;
512                 struct sas_task *task = isci_request_access_task(ireq);
513
514                 status = scic_sds_port_start_io(iport, idev, ireq);
515                 if (status != SCI_SUCCESS)
516                         return status;
517
518                 status = scic_sds_remote_node_context_start_io(&idev->rnc, ireq);
519                 if (status != SCI_SUCCESS)
520                         break;
521
522                 status = scic_sds_request_start(ireq);
523                 if (status != SCI_SUCCESS)
524                         break;
525
526                 if (task->ata_task.use_ncq)
527                         new_state = SCI_STP_DEV_NCQ;
528                 else {
529                         idev->working_request = ireq;
530                         new_state = SCI_STP_DEV_CMD;
531                 }
532                 sci_change_state(sm, new_state);
533                 break;
534         }
535         case SCI_STP_DEV_NCQ: {
536                 struct sas_task *task = isci_request_access_task(ireq);
537
538                 if (task->ata_task.use_ncq) {
539                         status = scic_sds_port_start_io(iport, idev, ireq);
540                         if (status != SCI_SUCCESS)
541                                 return status;
542
543                         status = scic_sds_remote_node_context_start_io(&idev->rnc, ireq);
544                         if (status != SCI_SUCCESS)
545                                 break;
546
547                         status = scic_sds_request_start(ireq);
548                 } else
549                         return SCI_FAILURE_INVALID_STATE;
550                 break;
551         }
552         case SCI_STP_DEV_AWAIT_RESET:
553                 return SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
554         case SCI_SMP_DEV_IDLE:
555                 status = scic_sds_port_start_io(iport, idev, ireq);
556                 if (status != SCI_SUCCESS)
557                         return status;
558
559                 status = scic_sds_remote_node_context_start_io(&idev->rnc, ireq);
560                 if (status != SCI_SUCCESS)
561                         break;
562
563                 status = scic_sds_request_start(ireq);
564                 if (status != SCI_SUCCESS)
565                         break;
566
567                 idev->working_request = ireq;
568                 sci_change_state(&idev->sm, SCI_SMP_DEV_CMD);
569                 break;
570         case SCI_STP_DEV_CMD:
571         case SCI_SMP_DEV_CMD:
572                 /* device is already handling a command it can not accept new commands
573                  * until this one is complete.
574                  */
575                 return SCI_FAILURE_INVALID_STATE;
576         }
577
578         scic_sds_remote_device_start_request(idev, ireq, status);
579         return status;
580 }
581
582 static enum sci_status common_complete_io(struct isci_port *iport,
583                                           struct isci_remote_device *idev,
584                                           struct isci_request *ireq)
585 {
586         enum sci_status status;
587
588         status = scic_sds_request_complete(ireq);
589         if (status != SCI_SUCCESS)
590                 return status;
591
592         status = scic_sds_port_complete_io(iport, idev, ireq);
593         if (status != SCI_SUCCESS)
594                 return status;
595
596         scic_sds_remote_device_decrement_request_count(idev);
597         return status;
598 }
599
600 enum sci_status scic_sds_remote_device_complete_io(struct scic_sds_controller *scic,
601                                                    struct isci_remote_device *idev,
602                                                    struct isci_request *ireq)
603 {
604         struct sci_base_state_machine *sm = &idev->sm;
605         enum scic_sds_remote_device_states state = sm->current_state_id;
606         struct isci_port *iport = idev->owning_port;
607         enum sci_status status;
608
609         switch (state) {
610         case SCI_DEV_INITIAL:
611         case SCI_DEV_STOPPED:
612         case SCI_DEV_STARTING:
613         case SCI_STP_DEV_IDLE:
614         case SCI_SMP_DEV_IDLE:
615         case SCI_DEV_FAILED:
616         case SCI_DEV_FINAL:
617         default:
618                 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
619                          __func__, state);
620                 return SCI_FAILURE_INVALID_STATE;
621         case SCI_DEV_READY:
622         case SCI_STP_DEV_AWAIT_RESET:
623         case SCI_DEV_RESETTING:
624                 status = common_complete_io(iport, idev, ireq);
625                 break;
626         case SCI_STP_DEV_CMD:
627         case SCI_STP_DEV_NCQ:
628         case SCI_STP_DEV_NCQ_ERROR:
629                 status = common_complete_io(iport, idev, ireq);
630                 if (status != SCI_SUCCESS)
631                         break;
632
633                 if (ireq->sci_status == SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED) {
634                         /* This request causes hardware error, device needs to be Lun Reset.
635                          * So here we force the state machine to IDLE state so the rest IOs
636                          * can reach RNC state handler, these IOs will be completed by RNC with
637                          * status of "DEVICE_RESET_REQUIRED", instead of "INVALID STATE".
638                          */
639                         sci_change_state(sm, SCI_STP_DEV_AWAIT_RESET);
640                 } else if (scic_sds_remote_device_get_request_count(idev) == 0)
641                         sci_change_state(sm, SCI_STP_DEV_IDLE);
642                 break;
643         case SCI_SMP_DEV_CMD:
644                 status = common_complete_io(iport, idev, ireq);
645                 if (status != SCI_SUCCESS)
646                         break;
647                 sci_change_state(sm, SCI_SMP_DEV_IDLE);
648                 break;
649         case SCI_DEV_STOPPING:
650                 status = common_complete_io(iport, idev, ireq);
651                 if (status != SCI_SUCCESS)
652                         break;
653
654                 if (scic_sds_remote_device_get_request_count(idev) == 0)
655                         scic_sds_remote_node_context_destruct(&idev->rnc,
656                                                               rnc_destruct_done,
657                                                               idev);
658                 break;
659         }
660
661         if (status != SCI_SUCCESS)
662                 dev_err(scirdev_to_dev(idev),
663                         "%s: Port:0x%p Device:0x%p Request:0x%p Status:0x%x "
664                         "could not complete\n", __func__, iport,
665                         idev, ireq, status);
666         else
667                 isci_put_device(idev);
668
669         return status;
670 }
671
672 static void scic_sds_remote_device_continue_request(void *dev)
673 {
674         struct isci_remote_device *idev = dev;
675
676         /* we need to check if this request is still valid to continue. */
677         if (idev->working_request)
678                 scic_controller_continue_io(idev->working_request);
679 }
680
681 enum sci_status scic_sds_remote_device_start_task(struct scic_sds_controller *scic,
682                                                   struct isci_remote_device *idev,
683                                                   struct isci_request *ireq)
684 {
685         struct sci_base_state_machine *sm = &idev->sm;
686         enum scic_sds_remote_device_states state = sm->current_state_id;
687         struct isci_port *iport = idev->owning_port;
688         enum sci_status status;
689
690         switch (state) {
691         case SCI_DEV_INITIAL:
692         case SCI_DEV_STOPPED:
693         case SCI_DEV_STARTING:
694         case SCI_SMP_DEV_IDLE:
695         case SCI_SMP_DEV_CMD:
696         case SCI_DEV_STOPPING:
697         case SCI_DEV_FAILED:
698         case SCI_DEV_RESETTING:
699         case SCI_DEV_FINAL:
700         default:
701                 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
702                          __func__, state);
703                 return SCI_FAILURE_INVALID_STATE;
704         case SCI_STP_DEV_IDLE:
705         case SCI_STP_DEV_CMD:
706         case SCI_STP_DEV_NCQ:
707         case SCI_STP_DEV_NCQ_ERROR:
708         case SCI_STP_DEV_AWAIT_RESET:
709                 status = scic_sds_port_start_io(iport, idev, ireq);
710                 if (status != SCI_SUCCESS)
711                         return status;
712
713                 status = scic_sds_remote_node_context_start_task(&idev->rnc, ireq);
714                 if (status != SCI_SUCCESS)
715                         goto out;
716
717                 status = scic_sds_request_start(ireq);
718                 if (status != SCI_SUCCESS)
719                         goto out;
720
721                 /* Note: If the remote device state is not IDLE this will
722                  * replace the request that probably resulted in the task
723                  * management request.
724                  */
725                 idev->working_request = ireq;
726                 sci_change_state(sm, SCI_STP_DEV_CMD);
727
728                 /* The remote node context must cleanup the TCi to NCQ mapping
729                  * table.  The only way to do this correctly is to either write
730                  * to the TLCR register or to invalidate and repost the RNC. In
731                  * either case the remote node context state machine will take
732                  * the correct action when the remote node context is suspended
733                  * and later resumed.
734                  */
735                 scic_sds_remote_node_context_suspend(&idev->rnc,
736                                 SCI_SOFTWARE_SUSPENSION, NULL, NULL);
737                 scic_sds_remote_node_context_resume(&idev->rnc,
738                                 scic_sds_remote_device_continue_request,
739                                                     idev);
740
741         out:
742                 scic_sds_remote_device_start_request(idev, ireq, status);
743                 /* We need to let the controller start request handler know that
744                  * it can't post TC yet. We will provide a callback function to
745                  * post TC when RNC gets resumed.
746                  */
747                 return SCI_FAILURE_RESET_DEVICE_PARTIAL_SUCCESS;
748         case SCI_DEV_READY:
749                 status = scic_sds_port_start_io(iport, idev, ireq);
750                 if (status != SCI_SUCCESS)
751                         return status;
752
753                 status = scic_sds_remote_node_context_start_task(&idev->rnc, ireq);
754                 if (status != SCI_SUCCESS)
755                         break;
756
757                 status = scic_sds_request_start(ireq);
758                 break;
759         }
760         scic_sds_remote_device_start_request(idev, ireq, status);
761
762         return status;
763 }
764
765 /**
766  *
767  * @sci_dev:
768  * @request:
769  *
770  * This method takes the request and bulids an appropriate SCU context for the
771  * request and then requests the controller to post the request. none
772  */
773 void scic_sds_remote_device_post_request(
774         struct isci_remote_device *idev,
775         u32 request)
776 {
777         u32 context;
778
779         context = scic_sds_remote_device_build_command_context(idev, request);
780
781         scic_sds_controller_post_request(
782                 scic_sds_remote_device_get_controller(idev),
783                 context
784                 );
785 }
786
787 /* called once the remote node context has transisitioned to a
788  * ready state.  This is the indication that the remote device object can also
789  * transition to ready.
790  */
791 static void remote_device_resume_done(void *_dev)
792 {
793         struct isci_remote_device *idev = _dev;
794
795         if (is_remote_device_ready(idev))
796                 return;
797
798         /* go 'ready' if we are not already in a ready state */
799         sci_change_state(&idev->sm, SCI_DEV_READY);
800 }
801
802 static void scic_sds_stp_remote_device_ready_idle_substate_resume_complete_handler(void *_dev)
803 {
804         struct isci_remote_device *idev = _dev;
805         struct scic_sds_controller *scic = idev->owning_port->owning_controller;
806
807         /* For NCQ operation we do not issue a isci_remote_device_not_ready().
808          * As a result, avoid sending the ready notification.
809          */
810         if (idev->sm.previous_state_id != SCI_STP_DEV_NCQ)
811                 isci_remote_device_ready(scic_to_ihost(scic), idev);
812 }
813
814 static void scic_sds_remote_device_initial_state_enter(struct sci_base_state_machine *sm)
815 {
816         struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
817
818         /* Initial state is a transitional state to the stopped state */
819         sci_change_state(&idev->sm, SCI_DEV_STOPPED);
820 }
821
822 /**
823  * scic_remote_device_destruct() - free remote node context and destruct
824  * @remote_device: This parameter specifies the remote device to be destructed.
825  *
826  * Remote device objects are a limited resource.  As such, they must be
827  * protected.  Thus calls to construct and destruct are mutually exclusive and
828  * non-reentrant. The return value shall indicate if the device was
829  * successfully destructed or if some failure occurred. enum sci_status This value
830  * is returned if the device is successfully destructed.
831  * SCI_FAILURE_INVALID_REMOTE_DEVICE This value is returned if the supplied
832  * device isn't valid (e.g. it's already been destoryed, the handle isn't
833  * valid, etc.).
834  */
835 static enum sci_status scic_remote_device_destruct(struct isci_remote_device *idev)
836 {
837         struct sci_base_state_machine *sm = &idev->sm;
838         enum scic_sds_remote_device_states state = sm->current_state_id;
839         struct scic_sds_controller *scic;
840
841         if (state != SCI_DEV_STOPPED) {
842                 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
843                          __func__, state);
844                 return SCI_FAILURE_INVALID_STATE;
845         }
846
847         scic = idev->owning_port->owning_controller;
848         scic_sds_controller_free_remote_node_context(scic, idev,
849                                                      idev->rnc.remote_node_index);
850         idev->rnc.remote_node_index = SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX;
851         sci_change_state(sm, SCI_DEV_FINAL);
852
853         return SCI_SUCCESS;
854 }
855
856 /**
857  * isci_remote_device_deconstruct() - This function frees an isci_remote_device.
858  * @ihost: This parameter specifies the isci host object.
859  * @idev: This parameter specifies the remote device to be freed.
860  *
861  */
862 static void isci_remote_device_deconstruct(struct isci_host *ihost, struct isci_remote_device *idev)
863 {
864         dev_dbg(&ihost->pdev->dev,
865                 "%s: isci_device = %p\n", __func__, idev);
866
867         /* There should not be any outstanding io's. All paths to
868          * here should go through isci_remote_device_nuke_requests.
869          * If we hit this condition, we will need a way to complete
870          * io requests in process */
871         BUG_ON(!list_empty(&idev->reqs_in_process));
872
873         scic_remote_device_destruct(idev);
874         list_del_init(&idev->node);
875         isci_put_device(idev);
876 }
877
878 static void scic_sds_remote_device_stopped_state_enter(struct sci_base_state_machine *sm)
879 {
880         struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
881         struct scic_sds_controller *scic = idev->owning_port->owning_controller;
882         u32 prev_state;
883
884         /* If we are entering from the stopping state let the SCI User know that
885          * the stop operation has completed.
886          */
887         prev_state = idev->sm.previous_state_id;
888         if (prev_state == SCI_DEV_STOPPING)
889                 isci_remote_device_deconstruct(scic_to_ihost(scic), idev);
890
891         scic_sds_controller_remote_device_stopped(scic, idev);
892 }
893
894 static void scic_sds_remote_device_starting_state_enter(struct sci_base_state_machine *sm)
895 {
896         struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
897         struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(idev);
898         struct isci_host *ihost = scic_to_ihost(scic);
899
900         isci_remote_device_not_ready(ihost, idev,
901                                      SCIC_REMOTE_DEVICE_NOT_READY_START_REQUESTED);
902 }
903
904 static void scic_sds_remote_device_ready_state_enter(struct sci_base_state_machine *sm)
905 {
906         struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
907         struct scic_sds_controller *scic = idev->owning_port->owning_controller;
908         struct domain_device *dev = idev->domain_dev;
909
910         if (dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_SATA)) {
911                 sci_change_state(&idev->sm, SCI_STP_DEV_IDLE);
912         } else if (dev_is_expander(dev)) {
913                 sci_change_state(&idev->sm, SCI_SMP_DEV_IDLE);
914         } else
915                 isci_remote_device_ready(scic_to_ihost(scic), idev);
916 }
917
918 static void scic_sds_remote_device_ready_state_exit(struct sci_base_state_machine *sm)
919 {
920         struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
921         struct domain_device *dev = idev->domain_dev;
922
923         if (dev->dev_type == SAS_END_DEV) {
924                 struct scic_sds_controller *scic = idev->owning_port->owning_controller;
925
926                 isci_remote_device_not_ready(scic_to_ihost(scic), idev,
927                                              SCIC_REMOTE_DEVICE_NOT_READY_STOP_REQUESTED);
928         }
929 }
930
931 static void scic_sds_remote_device_resetting_state_enter(struct sci_base_state_machine *sm)
932 {
933         struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
934
935         scic_sds_remote_node_context_suspend(
936                 &idev->rnc, SCI_SOFTWARE_SUSPENSION, NULL, NULL);
937 }
938
939 static void scic_sds_remote_device_resetting_state_exit(struct sci_base_state_machine *sm)
940 {
941         struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
942
943         scic_sds_remote_node_context_resume(&idev->rnc, NULL, NULL);
944 }
945
946 static void scic_sds_stp_remote_device_ready_idle_substate_enter(struct sci_base_state_machine *sm)
947 {
948         struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
949
950         idev->working_request = NULL;
951         if (scic_sds_remote_node_context_is_ready(&idev->rnc)) {
952                 /*
953                  * Since the RNC is ready, it's alright to finish completion
954                  * processing (e.g. signal the remote device is ready). */
955                 scic_sds_stp_remote_device_ready_idle_substate_resume_complete_handler(idev);
956         } else {
957                 scic_sds_remote_node_context_resume(&idev->rnc,
958                         scic_sds_stp_remote_device_ready_idle_substate_resume_complete_handler,
959                         idev);
960         }
961 }
962
963 static void scic_sds_stp_remote_device_ready_cmd_substate_enter(struct sci_base_state_machine *sm)
964 {
965         struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
966         struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(idev);
967
968         BUG_ON(idev->working_request == NULL);
969
970         isci_remote_device_not_ready(scic_to_ihost(scic), idev,
971                                      SCIC_REMOTE_DEVICE_NOT_READY_SATA_REQUEST_STARTED);
972 }
973
974 static void scic_sds_stp_remote_device_ready_ncq_error_substate_enter(struct sci_base_state_machine *sm)
975 {
976         struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
977         struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(idev);
978
979         if (idev->not_ready_reason == SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED)
980                 isci_remote_device_not_ready(scic_to_ihost(scic), idev,
981                                              idev->not_ready_reason);
982 }
983
984 static void scic_sds_smp_remote_device_ready_idle_substate_enter(struct sci_base_state_machine *sm)
985 {
986         struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
987         struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(idev);
988
989         isci_remote_device_ready(scic_to_ihost(scic), idev);
990 }
991
992 static void scic_sds_smp_remote_device_ready_cmd_substate_enter(struct sci_base_state_machine *sm)
993 {
994         struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
995         struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(idev);
996
997         BUG_ON(idev->working_request == NULL);
998
999         isci_remote_device_not_ready(scic_to_ihost(scic), idev,
1000                                      SCIC_REMOTE_DEVICE_NOT_READY_SMP_REQUEST_STARTED);
1001 }
1002
1003 static void scic_sds_smp_remote_device_ready_cmd_substate_exit(struct sci_base_state_machine *sm)
1004 {
1005         struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1006
1007         idev->working_request = NULL;
1008 }
1009
1010 static const struct sci_base_state scic_sds_remote_device_state_table[] = {
1011         [SCI_DEV_INITIAL] = {
1012                 .enter_state = scic_sds_remote_device_initial_state_enter,
1013         },
1014         [SCI_DEV_STOPPED] = {
1015                 .enter_state = scic_sds_remote_device_stopped_state_enter,
1016         },
1017         [SCI_DEV_STARTING] = {
1018                 .enter_state = scic_sds_remote_device_starting_state_enter,
1019         },
1020         [SCI_DEV_READY] = {
1021                 .enter_state = scic_sds_remote_device_ready_state_enter,
1022                 .exit_state  = scic_sds_remote_device_ready_state_exit
1023         },
1024         [SCI_STP_DEV_IDLE] = {
1025                 .enter_state = scic_sds_stp_remote_device_ready_idle_substate_enter,
1026         },
1027         [SCI_STP_DEV_CMD] = {
1028                 .enter_state = scic_sds_stp_remote_device_ready_cmd_substate_enter,
1029         },
1030         [SCI_STP_DEV_NCQ] = { },
1031         [SCI_STP_DEV_NCQ_ERROR] = {
1032                 .enter_state = scic_sds_stp_remote_device_ready_ncq_error_substate_enter,
1033         },
1034         [SCI_STP_DEV_AWAIT_RESET] = { },
1035         [SCI_SMP_DEV_IDLE] = {
1036                 .enter_state = scic_sds_smp_remote_device_ready_idle_substate_enter,
1037         },
1038         [SCI_SMP_DEV_CMD] = {
1039                 .enter_state = scic_sds_smp_remote_device_ready_cmd_substate_enter,
1040                 .exit_state  = scic_sds_smp_remote_device_ready_cmd_substate_exit,
1041         },
1042         [SCI_DEV_STOPPING] = { },
1043         [SCI_DEV_FAILED] = { },
1044         [SCI_DEV_RESETTING] = {
1045                 .enter_state = scic_sds_remote_device_resetting_state_enter,
1046                 .exit_state  = scic_sds_remote_device_resetting_state_exit
1047         },
1048         [SCI_DEV_FINAL] = { },
1049 };
1050
1051 /**
1052  * scic_remote_device_construct() - common construction
1053  * @sci_port: SAS/SATA port through which this device is accessed.
1054  * @sci_dev: remote device to construct
1055  *
1056  * This routine just performs benign initialization and does not
1057  * allocate the remote_node_context which is left to
1058  * scic_remote_device_[de]a_construct().  scic_remote_device_destruct()
1059  * frees the remote_node_context(s) for the device.
1060  */
1061 static void scic_remote_device_construct(struct isci_port *iport,
1062                                   struct isci_remote_device *idev)
1063 {
1064         idev->owning_port = iport;
1065         idev->started_request_count = 0;
1066
1067         sci_init_sm(&idev->sm, scic_sds_remote_device_state_table, SCI_DEV_INITIAL);
1068
1069         scic_sds_remote_node_context_construct(&idev->rnc,
1070                                                SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX);
1071 }
1072
1073 /**
1074  * scic_remote_device_da_construct() - construct direct attached device.
1075  *
1076  * The information (e.g. IAF, Signature FIS, etc.) necessary to build
1077  * the device is known to the SCI Core since it is contained in the
1078  * scic_phy object.  Remote node context(s) is/are a global resource
1079  * allocated by this routine, freed by scic_remote_device_destruct().
1080  *
1081  * Returns:
1082  * SCI_FAILURE_DEVICE_EXISTS - device has already been constructed.
1083  * SCI_FAILURE_UNSUPPORTED_PROTOCOL - e.g. sas device attached to
1084  * sata-only controller instance.
1085  * SCI_FAILURE_INSUFFICIENT_RESOURCES - remote node contexts exhausted.
1086  */
1087 static enum sci_status scic_remote_device_da_construct(struct isci_port *iport,
1088                                                        struct isci_remote_device *idev)
1089 {
1090         enum sci_status status;
1091         struct domain_device *dev = idev->domain_dev;
1092
1093         scic_remote_device_construct(iport, idev);
1094
1095         /*
1096          * This information is request to determine how many remote node context
1097          * entries will be needed to store the remote node.
1098          */
1099         idev->is_direct_attached = true;
1100         status = scic_sds_controller_allocate_remote_node_context(iport->owning_controller,
1101                                                                   idev,
1102                                                                   &idev->rnc.remote_node_index);
1103
1104         if (status != SCI_SUCCESS)
1105                 return status;
1106
1107         if (dev->dev_type == SAS_END_DEV || dev->dev_type == SATA_DEV ||
1108             (dev->tproto & SAS_PROTOCOL_STP) || dev_is_expander(dev))
1109                 /* pass */;
1110         else
1111                 return SCI_FAILURE_UNSUPPORTED_PROTOCOL;
1112
1113         idev->connection_rate = scic_sds_port_get_max_allowed_speed(iport);
1114
1115         /* / @todo Should I assign the port width by reading all of the phys on the port? */
1116         idev->device_port_width = 1;
1117
1118         return SCI_SUCCESS;
1119 }
1120
1121 /**
1122  * scic_remote_device_ea_construct() - construct expander attached device
1123  *
1124  * Remote node context(s) is/are a global resource allocated by this
1125  * routine, freed by scic_remote_device_destruct().
1126  *
1127  * Returns:
1128  * SCI_FAILURE_DEVICE_EXISTS - device has already been constructed.
1129  * SCI_FAILURE_UNSUPPORTED_PROTOCOL - e.g. sas device attached to
1130  * sata-only controller instance.
1131  * SCI_FAILURE_INSUFFICIENT_RESOURCES - remote node contexts exhausted.
1132  */
1133 static enum sci_status scic_remote_device_ea_construct(struct isci_port *iport,
1134                                                        struct isci_remote_device *idev)
1135 {
1136         struct domain_device *dev = idev->domain_dev;
1137         enum sci_status status;
1138
1139         scic_remote_device_construct(iport, idev);
1140
1141         status = scic_sds_controller_allocate_remote_node_context(iport->owning_controller,
1142                                                                   idev,
1143                                                                   &idev->rnc.remote_node_index);
1144         if (status != SCI_SUCCESS)
1145                 return status;
1146
1147         if (dev->dev_type == SAS_END_DEV || dev->dev_type == SATA_DEV ||
1148             (dev->tproto & SAS_PROTOCOL_STP) || dev_is_expander(dev))
1149                 /* pass */;
1150         else
1151                 return SCI_FAILURE_UNSUPPORTED_PROTOCOL;
1152
1153         /*
1154          * For SAS-2 the physical link rate is actually a logical link
1155          * rate that incorporates multiplexing.  The SCU doesn't
1156          * incorporate multiplexing and for the purposes of the
1157          * connection the logical link rate is that same as the
1158          * physical.  Furthermore, the SAS-2 and SAS-1.1 fields overlay
1159          * one another, so this code works for both situations. */
1160         idev->connection_rate = min_t(u16, scic_sds_port_get_max_allowed_speed(iport),
1161                                          dev->linkrate);
1162
1163         /* / @todo Should I assign the port width by reading all of the phys on the port? */
1164         idev->device_port_width = 1;
1165
1166         return SCI_SUCCESS;
1167 }
1168
1169 /**
1170  * scic_remote_device_start() - This method will start the supplied remote
1171  *    device.  This method enables normal IO requests to flow through to the
1172  *    remote device.
1173  * @remote_device: This parameter specifies the device to be started.
1174  * @timeout: This parameter specifies the number of milliseconds in which the
1175  *    start operation should complete.
1176  *
1177  * An indication of whether the device was successfully started. SCI_SUCCESS
1178  * This value is returned if the device was successfully started.
1179  * SCI_FAILURE_INVALID_PHY This value is returned if the user attempts to start
1180  * the device when there have been no phys added to it.
1181  */
1182 static enum sci_status scic_remote_device_start(struct isci_remote_device *idev,
1183                                                 u32 timeout)
1184 {
1185         struct sci_base_state_machine *sm = &idev->sm;
1186         enum scic_sds_remote_device_states state = sm->current_state_id;
1187         enum sci_status status;
1188
1189         if (state != SCI_DEV_STOPPED) {
1190                 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
1191                          __func__, state);
1192                 return SCI_FAILURE_INVALID_STATE;
1193         }
1194
1195         status = scic_sds_remote_node_context_resume(&idev->rnc,
1196                                                      remote_device_resume_done,
1197                                                      idev);
1198         if (status != SCI_SUCCESS)
1199                 return status;
1200
1201         sci_change_state(sm, SCI_DEV_STARTING);
1202
1203         return SCI_SUCCESS;
1204 }
1205
1206 static enum sci_status isci_remote_device_construct(struct isci_port *iport,
1207                                                     struct isci_remote_device *idev)
1208 {
1209         struct isci_host *ihost = iport->isci_host;
1210         struct domain_device *dev = idev->domain_dev;
1211         enum sci_status status;
1212
1213         if (dev->parent && dev_is_expander(dev->parent))
1214                 status = scic_remote_device_ea_construct(iport, idev);
1215         else
1216                 status = scic_remote_device_da_construct(iport, idev);
1217
1218         if (status != SCI_SUCCESS) {
1219                 dev_dbg(&ihost->pdev->dev, "%s: construct failed: %d\n",
1220                         __func__, status);
1221
1222                 return status;
1223         }
1224
1225         /* start the device. */
1226         status = scic_remote_device_start(idev, ISCI_REMOTE_DEVICE_START_TIMEOUT);
1227
1228         if (status != SCI_SUCCESS)
1229                 dev_warn(&ihost->pdev->dev, "remote device start failed: %d\n",
1230                          status);
1231
1232         return status;
1233 }
1234
1235 void isci_remote_device_nuke_requests(struct isci_host *ihost, struct isci_remote_device *idev)
1236 {
1237         DECLARE_COMPLETION_ONSTACK(aborted_task_completion);
1238
1239         dev_dbg(&ihost->pdev->dev,
1240                 "%s: idev = %p\n", __func__, idev);
1241
1242         /* Cleanup all requests pending for this device. */
1243         isci_terminate_pending_requests(ihost, idev);
1244
1245         dev_dbg(&ihost->pdev->dev,
1246                 "%s: idev = %p, done\n", __func__, idev);
1247 }
1248
1249 /**
1250  * This function builds the isci_remote_device when a libsas dev_found message
1251  *    is received.
1252  * @isci_host: This parameter specifies the isci host object.
1253  * @port: This parameter specifies the isci_port conected to this device.
1254  *
1255  * pointer to new isci_remote_device.
1256  */
1257 static struct isci_remote_device *
1258 isci_remote_device_alloc(struct isci_host *ihost, struct isci_port *iport)
1259 {
1260         struct isci_remote_device *idev;
1261         int i;
1262
1263         for (i = 0; i < SCI_MAX_REMOTE_DEVICES; i++) {
1264                 idev = &ihost->devices[i];
1265                 if (!test_and_set_bit(IDEV_ALLOCATED, &idev->flags))
1266                         break;
1267         }
1268
1269         if (i >= SCI_MAX_REMOTE_DEVICES) {
1270                 dev_warn(&ihost->pdev->dev, "%s: failed\n", __func__);
1271                 return NULL;
1272         }
1273
1274         if (WARN_ONCE(!list_empty(&idev->reqs_in_process), "found requests in process\n"))
1275                 return NULL;
1276
1277         if (WARN_ONCE(!list_empty(&idev->node), "found non-idle remote device\n"))
1278                 return NULL;
1279
1280         return idev;
1281 }
1282
1283 void isci_remote_device_release(struct kref *kref)
1284 {
1285         struct isci_remote_device *idev = container_of(kref, typeof(*idev), kref);
1286         struct isci_host *ihost = idev->isci_port->isci_host;
1287
1288         idev->domain_dev = NULL;
1289         idev->isci_port = NULL;
1290         clear_bit(IDEV_START_PENDING, &idev->flags);
1291         clear_bit(IDEV_STOP_PENDING, &idev->flags);
1292         clear_bit(IDEV_IO_READY, &idev->flags);
1293         clear_bit(IDEV_GONE, &idev->flags);
1294         clear_bit(IDEV_EH, &idev->flags);
1295         smp_mb__before_clear_bit();
1296         clear_bit(IDEV_ALLOCATED, &idev->flags);
1297         wake_up(&ihost->eventq);
1298 }
1299
1300 /**
1301  * isci_remote_device_stop() - This function is called internally to stop the
1302  *    remote device.
1303  * @isci_host: This parameter specifies the isci host object.
1304  * @isci_device: This parameter specifies the remote device.
1305  *
1306  * The status of the scic request to stop.
1307  */
1308 enum sci_status isci_remote_device_stop(struct isci_host *ihost, struct isci_remote_device *idev)
1309 {
1310         enum sci_status status;
1311         unsigned long flags;
1312
1313         dev_dbg(&ihost->pdev->dev,
1314                 "%s: isci_device = %p\n", __func__, idev);
1315
1316         spin_lock_irqsave(&ihost->scic_lock, flags);
1317         idev->domain_dev->lldd_dev = NULL; /* disable new lookups */
1318         set_bit(IDEV_GONE, &idev->flags);
1319         spin_unlock_irqrestore(&ihost->scic_lock, flags);
1320
1321         /* Kill all outstanding requests. */
1322         isci_remote_device_nuke_requests(ihost, idev);
1323
1324         set_bit(IDEV_STOP_PENDING, &idev->flags);
1325
1326         spin_lock_irqsave(&ihost->scic_lock, flags);
1327         status = scic_remote_device_stop(idev, 50);
1328         spin_unlock_irqrestore(&ihost->scic_lock, flags);
1329
1330         /* Wait for the stop complete callback. */
1331         if (WARN_ONCE(status != SCI_SUCCESS, "failed to stop device\n"))
1332                 /* nothing to wait for */;
1333         else
1334                 wait_for_device_stop(ihost, idev);
1335
1336         return status;
1337 }
1338
1339 /**
1340  * isci_remote_device_gone() - This function is called by libsas when a domain
1341  *    device is removed.
1342  * @domain_device: This parameter specifies the libsas domain device.
1343  *
1344  */
1345 void isci_remote_device_gone(struct domain_device *dev)
1346 {
1347         struct isci_host *ihost = dev_to_ihost(dev);
1348         struct isci_remote_device *idev = dev->lldd_dev;
1349
1350         dev_dbg(&ihost->pdev->dev,
1351                 "%s: domain_device = %p, isci_device = %p, isci_port = %p\n",
1352                 __func__, dev, idev, idev->isci_port);
1353
1354         isci_remote_device_stop(ihost, idev);
1355 }
1356
1357
1358 /**
1359  * isci_remote_device_found() - This function is called by libsas when a remote
1360  *    device is discovered. A remote device object is created and started. the
1361  *    function then sleeps until the sci core device started message is
1362  *    received.
1363  * @domain_device: This parameter specifies the libsas domain device.
1364  *
1365  * status, zero indicates success.
1366  */
1367 int isci_remote_device_found(struct domain_device *domain_dev)
1368 {
1369         struct isci_host *isci_host = dev_to_ihost(domain_dev);
1370         struct isci_port *isci_port;
1371         struct isci_phy *isci_phy;
1372         struct asd_sas_port *sas_port;
1373         struct asd_sas_phy *sas_phy;
1374         struct isci_remote_device *isci_device;
1375         enum sci_status status;
1376
1377         dev_dbg(&isci_host->pdev->dev,
1378                 "%s: domain_device = %p\n", __func__, domain_dev);
1379
1380         wait_for_start(isci_host);
1381
1382         sas_port = domain_dev->port;
1383         sas_phy = list_first_entry(&sas_port->phy_list, struct asd_sas_phy,
1384                                    port_phy_el);
1385         isci_phy = to_iphy(sas_phy);
1386         isci_port = isci_phy->isci_port;
1387
1388         /* we are being called for a device on this port,
1389          * so it has to come up eventually
1390          */
1391         wait_for_completion(&isci_port->start_complete);
1392
1393         if ((isci_stopping == isci_port_get_state(isci_port)) ||
1394             (isci_stopped == isci_port_get_state(isci_port)))
1395                 return -ENODEV;
1396
1397         isci_device = isci_remote_device_alloc(isci_host, isci_port);
1398         if (!isci_device)
1399                 return -ENODEV;
1400
1401         kref_init(&isci_device->kref);
1402         INIT_LIST_HEAD(&isci_device->node);
1403
1404         spin_lock_irq(&isci_host->scic_lock);
1405         isci_device->domain_dev = domain_dev;
1406         isci_device->isci_port = isci_port;
1407         list_add_tail(&isci_device->node, &isci_port->remote_dev_list);
1408
1409         set_bit(IDEV_START_PENDING, &isci_device->flags);
1410         status = isci_remote_device_construct(isci_port, isci_device);
1411
1412         dev_dbg(&isci_host->pdev->dev,
1413                 "%s: isci_device = %p\n",
1414                 __func__, isci_device);
1415
1416         if (status == SCI_SUCCESS) {
1417                 /* device came up, advertise it to the world */
1418                 domain_dev->lldd_dev = isci_device;
1419         } else
1420                 isci_put_device(isci_device);
1421         spin_unlock_irq(&isci_host->scic_lock);
1422
1423         /* wait for the device ready callback. */
1424         wait_for_device_start(isci_host, isci_device);
1425
1426         return status == SCI_SUCCESS ? 0 : -ENODEV;
1427 }
1428 /**
1429  * isci_device_is_reset_pending() - This function will check if there is any
1430  *    pending reset condition on the device.
1431  * @request: This parameter is the isci_device object.
1432  *
1433  * true if there is a reset pending for the device.
1434  */
1435 bool isci_device_is_reset_pending(
1436         struct isci_host *isci_host,
1437         struct isci_remote_device *isci_device)
1438 {
1439         struct isci_request *isci_request;
1440         struct isci_request *tmp_req;
1441         bool reset_is_pending = false;
1442         unsigned long flags;
1443
1444         dev_dbg(&isci_host->pdev->dev,
1445                 "%s: isci_device = %p\n", __func__, isci_device);
1446
1447         spin_lock_irqsave(&isci_host->scic_lock, flags);
1448
1449         /* Check for reset on all pending requests. */
1450         list_for_each_entry_safe(isci_request, tmp_req,
1451                                  &isci_device->reqs_in_process, dev_node) {
1452                 dev_dbg(&isci_host->pdev->dev,
1453                         "%s: isci_device = %p request = %p\n",
1454                         __func__, isci_device, isci_request);
1455
1456                 if (isci_request->ttype == io_task) {
1457                         struct sas_task *task = isci_request_access_task(
1458                                 isci_request);
1459
1460                         spin_lock(&task->task_state_lock);
1461                         if (task->task_state_flags & SAS_TASK_NEED_DEV_RESET)
1462                                 reset_is_pending = true;
1463                         spin_unlock(&task->task_state_lock);
1464                 }
1465         }
1466
1467         spin_unlock_irqrestore(&isci_host->scic_lock, flags);
1468
1469         dev_dbg(&isci_host->pdev->dev,
1470                 "%s: isci_device = %p reset_is_pending = %d\n",
1471                 __func__, isci_device, reset_is_pending);
1472
1473         return reset_is_pending;
1474 }
1475
1476 /**
1477  * isci_device_clear_reset_pending() - This function will clear if any pending
1478  *    reset condition flags on the device.
1479  * @request: This parameter is the isci_device object.
1480  *
1481  * true if there is a reset pending for the device.
1482  */
1483 void isci_device_clear_reset_pending(struct isci_host *ihost, struct isci_remote_device *idev)
1484 {
1485         struct isci_request *isci_request;
1486         struct isci_request *tmp_req;
1487         unsigned long flags = 0;
1488
1489         dev_dbg(&ihost->pdev->dev, "%s: idev=%p, ihost=%p\n",
1490                  __func__, idev, ihost);
1491
1492         spin_lock_irqsave(&ihost->scic_lock, flags);
1493
1494         /* Clear reset pending on all pending requests. */
1495         list_for_each_entry_safe(isci_request, tmp_req,
1496                                  &idev->reqs_in_process, dev_node) {
1497                 dev_dbg(&ihost->pdev->dev, "%s: idev = %p request = %p\n",
1498                          __func__, idev, isci_request);
1499
1500                 if (isci_request->ttype == io_task) {
1501
1502                         unsigned long flags2;
1503                         struct sas_task *task = isci_request_access_task(
1504                                 isci_request);
1505
1506                         spin_lock_irqsave(&task->task_state_lock, flags2);
1507                         task->task_state_flags &= ~SAS_TASK_NEED_DEV_RESET;
1508                         spin_unlock_irqrestore(&task->task_state_lock, flags2);
1509                 }
1510         }
1511         spin_unlock_irqrestore(&ihost->scic_lock, flags);
1512 }