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