blob: 37ffedc94ac02107c7989407c61891a9f8a46c1f [file] [log] [blame]
Dan Williams6f231dd2011-07-02 22:56:22 -07001/*
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
56#include "isci.h"
57#include "scic_remote_device.h"
58#include "scic_io_request.h"
59#include "scic_task_request.h"
60#include "scic_port.h"
61#include "task.h"
62#include "request.h"
63#include "sata.h"
64#include "scu_completion_codes.h"
65
66
67static enum sci_status isci_request_ssp_request_construct(
68 struct isci_request *request)
69{
70 enum sci_status status;
71
72 dev_dbg(&request->isci_host->pdev->dev,
73 "%s: request = %p\n",
74 __func__,
75 request);
76 status = scic_io_request_construct_basic_ssp(
77 request->sci_request_handle
78 );
79 return status;
80}
81
82static enum sci_status isci_request_stp_request_construct(
83 struct isci_request *request)
84{
85 struct sas_task *task = isci_request_access_task(request);
86 enum sci_status status;
87 struct host_to_dev_fis *register_fis;
88
89 dev_dbg(&request->isci_host->pdev->dev,
90 "%s: request = %p\n",
91 __func__,
92 request);
93
94 /* Get the host_to_dev_fis from the core and copy
95 * the fis from the task into it.
96 */
97 register_fis = isci_sata_task_to_fis_copy(task);
98
99 status = scic_io_request_construct_basic_sata(
100 request->sci_request_handle
101 );
102
103 /* Set the ncq tag in the fis, from the queue
104 * command in the task.
105 */
106 if (isci_sata_is_task_ncq(task)) {
107
108 isci_sata_set_ncq_tag(
109 register_fis,
110 task
111 );
112 }
113
114 return status;
115}
116
117/**
118 * isci_smp_request_build() - This function builds the smp request object.
119 * @isci_host: This parameter specifies the ISCI host object
120 * @request: This parameter points to the isci_request object allocated in the
121 * request construct function.
122 * @sci_device: This parameter is the handle for the sci core's remote device
123 * object that is the destination for this request.
124 *
125 * SCI_SUCCESS on successfull completion, or specific failure code.
126 */
127static enum sci_status isci_smp_request_build(
128 struct isci_request *request)
129{
130 enum sci_status status = SCI_FAILURE;
131 struct sas_task *task = isci_request_access_task(request);
132
133 void *command_iu_address =
134 scic_io_request_get_command_iu_address(
135 request->sci_request_handle
136 );
137
138 dev_dbg(&request->isci_host->pdev->dev,
139 "%s: request = %p\n",
140 __func__,
141 request);
142 dev_dbg(&request->isci_host->pdev->dev,
143 "%s: smp_req len = %d\n",
144 __func__,
145 task->smp_task.smp_req.length);
146
147 /* copy the smp_command to the address; */
148 sg_copy_to_buffer(&task->smp_task.smp_req, 1,
149 (char *)command_iu_address,
150 sizeof(struct smp_request)
151 );
152
153 status = scic_io_request_construct_smp(request->sci_request_handle);
154 if (status != SCI_SUCCESS)
155 dev_warn(&request->isci_host->pdev->dev,
156 "%s: scic_io_request_construct_smp failed with "
157 "status = %d\n",
158 __func__,
159 status);
160
161 return status;
162}
163
164/**
165 * isci_io_request_build() - This function builds the io request object.
166 * @isci_host: This parameter specifies the ISCI host object
167 * @request: This parameter points to the isci_request object allocated in the
168 * request construct function.
169 * @sci_device: This parameter is the handle for the sci core's remote device
170 * object that is the destination for this request.
171 *
172 * SCI_SUCCESS on successfull completion, or specific failure code.
173 */
174static enum sci_status isci_io_request_build(
175 struct isci_host *isci_host,
176 struct isci_request *request,
177 struct isci_remote_device *isci_device)
178{
179 struct smp_discover_response_protocols dev_protocols;
180 enum sci_status status = SCI_SUCCESS;
181 struct sas_task *task = isci_request_access_task(request);
Dan Williams3a97eec2011-03-04 11:51:43 -0800182 struct scic_sds_remote_device *sci_device = to_sci_dev(isci_device);
Dan Williams6f231dd2011-07-02 22:56:22 -0700183
184 dev_dbg(&isci_host->pdev->dev,
185 "%s: isci_device = 0x%p; request = %p, "
186 "num_scatter = %d\n",
187 __func__,
188 isci_device,
189 request,
190 task->num_scatter);
191
192 /* map the sgl addresses, if present.
193 * libata does the mapping for sata devices
194 * before we get the request.
195 */
196 if (task->num_scatter &&
197 !sas_protocol_ata(task->task_proto) &&
198 !(SAS_PROTOCOL_SMP & task->task_proto)) {
199
200 request->num_sg_entries = dma_map_sg(
201 &isci_host->pdev->dev,
202 task->scatter,
203 task->num_scatter,
204 task->data_dir
205 );
206
207 if (request->num_sg_entries == 0)
208 return SCI_FAILURE_INSUFFICIENT_RESOURCES;
209 }
210
211 /* build the common request object. For now,
212 * we will let the core allocate the IO tag.
213 */
214 status = scic_io_request_construct(
215 isci_host->core_controller,
216 sci_device,
217 SCI_CONTROLLER_INVALID_IO_TAG,
218 request,
219 request->sci_request_mem_ptr,
220 (struct scic_sds_request **)&request->sci_request_handle
221 );
222
223 if (status != SCI_SUCCESS) {
224 dev_warn(&isci_host->pdev->dev,
225 "%s: failed request construct\n",
226 __func__);
227 return SCI_FAILURE;
228 }
229
230 sci_object_set_association(request->sci_request_handle, request);
231
232 /* Determine protocol and call the appropriate basic constructor */
233 scic_remote_device_get_protocols(sci_device, &dev_protocols);
234 if (dev_protocols.u.bits.attached_ssp_target)
235 status = isci_request_ssp_request_construct(request);
236 else if (dev_protocols.u.bits.attached_stp_target)
237 status = isci_request_stp_request_construct(request);
238 else if (dev_protocols.u.bits.attached_smp_target)
239 status = isci_smp_request_build(request);
240 else {
241 dev_warn(&isci_host->pdev->dev,
242 "%s: unknown protocol\n", __func__);
243 return SCI_FAILURE;
244 }
245
246 return SCI_SUCCESS;
247}
248
249
250/**
251 * isci_request_alloc_core() - This function gets the request object from the
252 * isci_host dma cache.
253 * @isci_host: This parameter specifies the ISCI host object
254 * @isci_request: This parameter will contain the pointer to the new
255 * isci_request object.
256 * @isci_device: This parameter is the pointer to the isci remote device object
257 * that is the destination for this request.
258 * @gfp_flags: This parameter specifies the os allocation flags.
259 *
260 * SCI_SUCCESS on successfull completion, or specific failure code.
261 */
262static int isci_request_alloc_core(
263 struct isci_host *isci_host,
264 struct isci_request **isci_request,
265 struct isci_remote_device *isci_device,
266 gfp_t gfp_flags)
267{
268 int ret = 0;
269 dma_addr_t handle;
270 struct isci_request *request;
271
272
273 /* get pointer to dma memory. This actually points
274 * to both the isci_remote_device object and the
275 * sci object. The isci object is at the beginning
276 * of the memory allocated here.
277 */
278 request = dma_pool_alloc(isci_host->dma_pool, gfp_flags, &handle);
279 if (!request) {
280 dev_warn(&isci_host->pdev->dev,
281 "%s: dma_pool_alloc returned NULL\n", __func__);
282 return -ENOMEM;
283 }
284
285 /* initialize the request object. */
286 spin_lock_init(&request->state_lock);
Dan Williams6f231dd2011-07-02 22:56:22 -0700287 request->sci_request_mem_ptr = ((u8 *)request) +
288 sizeof(struct isci_request);
289 request->request_daddr = handle;
290 request->isci_host = isci_host;
291 request->isci_device = isci_device;
292 request->io_request_completion = NULL;
293
294 request->request_alloc_size = isci_host->dma_pool_alloc_size;
295 request->num_sg_entries = 0;
296
297 request->complete_in_target = false;
298
299 INIT_LIST_HEAD(&request->completed_node);
300 INIT_LIST_HEAD(&request->dev_node);
301
302 *isci_request = request;
Dan Williams83f5eee2011-02-18 09:25:15 -0800303 isci_request_change_state(request, allocated);
Dan Williams6f231dd2011-07-02 22:56:22 -0700304
305 return ret;
306}
307
308static int isci_request_alloc_io(
309 struct isci_host *isci_host,
310 struct sas_task *task,
311 struct isci_request **isci_request,
312 struct isci_remote_device *isci_device,
313 gfp_t gfp_flags)
314{
315 int retval = isci_request_alloc_core(isci_host, isci_request,
316 isci_device, gfp_flags);
317
318 if (!retval) {
319 (*isci_request)->ttype_ptr.io_task_ptr = task;
320 (*isci_request)->ttype = io_task;
321
322 task->lldd_task = *isci_request;
323 }
324 return retval;
325}
326
327/**
328 * isci_request_alloc_tmf() - This function gets the request object from the
329 * isci_host dma cache and initializes the relevant fields as a sas_task.
330 * @isci_host: This parameter specifies the ISCI host object
331 * @sas_task: This parameter is the task struct from the upper layer driver.
332 * @isci_request: This parameter will contain the pointer to the new
333 * isci_request object.
334 * @isci_device: This parameter is the pointer to the isci remote device object
335 * that is the destination for this request.
336 * @gfp_flags: This parameter specifies the os allocation flags.
337 *
338 * SCI_SUCCESS on successfull completion, or specific failure code.
339 */
340int isci_request_alloc_tmf(
341 struct isci_host *isci_host,
342 struct isci_tmf *isci_tmf,
343 struct isci_request **isci_request,
344 struct isci_remote_device *isci_device,
345 gfp_t gfp_flags)
346{
347 int retval = isci_request_alloc_core(isci_host, isci_request,
348 isci_device, gfp_flags);
349
350 if (!retval) {
351
352 (*isci_request)->ttype_ptr.tmf_task_ptr = isci_tmf;
353 (*isci_request)->ttype = tmf_task;
354 }
355 return retval;
356}
357
358/**
Dan Williams6f231dd2011-07-02 22:56:22 -0700359 * isci_request_execute() - This function allocates the isci_request object,
360 * all fills in some common fields.
361 * @isci_host: This parameter specifies the ISCI host object
362 * @sas_task: This parameter is the task struct from the upper layer driver.
363 * @isci_request: This parameter will contain the pointer to the new
364 * isci_request object.
365 * @gfp_flags: This parameter specifies the os allocation flags.
366 *
367 * SCI_SUCCESS on successfull completion, or specific failure code.
368 */
369int isci_request_execute(
370 struct isci_host *isci_host,
371 struct sas_task *task,
372 struct isci_request **isci_request,
373 gfp_t gfp_flags)
374{
375 int ret = 0;
376 struct scic_sds_remote_device *sci_device;
377 enum sci_status status = SCI_FAILURE_UNSUPPORTED_PROTOCOL;
378 struct isci_remote_device *isci_device;
379 struct isci_request *request;
380 unsigned long flags;
381
Dan Williams4393aa42011-03-31 13:10:44 -0700382 isci_device = task->dev->lldd_dev;
Dan Williams3a97eec2011-03-04 11:51:43 -0800383 sci_device = to_sci_dev(isci_device);
Dan Williams6f231dd2011-07-02 22:56:22 -0700384
385 /* do common allocation and init of request object. */
386 ret = isci_request_alloc_io(
387 isci_host,
388 task,
389 &request,
390 isci_device,
391 gfp_flags
392 );
393
394 if (ret)
395 goto out;
396
397 status = isci_io_request_build(isci_host, request, isci_device);
398 if (status == SCI_SUCCESS) {
399
400 spin_lock_irqsave(&isci_host->scic_lock, flags);
401
402 /* send the request, let the core assign the IO TAG. */
403 status = scic_controller_start_io(
404 isci_host->core_controller,
405 sci_device,
406 request->sci_request_handle,
407 SCI_CONTROLLER_INVALID_IO_TAG
408 );
409
410 if (status == SCI_SUCCESS ||
411 status == SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED) {
412
413 /* Either I/O started OK, or the core has signaled that
414 * the device needs a target reset.
415 *
416 * In either case, hold onto the I/O for later.
417 *
418 * Update it's status and add it to the list in the
419 * remote device object.
420 */
421 isci_request_change_state(request, started);
422 list_add(&request->dev_node,
423 &isci_device->reqs_in_process);
424
Jeff Skirvinc4b9e242011-03-16 09:41:59 -0700425 if (status == SCI_SUCCESS) {
Jeff Skirvin1fad9e92011-03-04 14:06:46 -0800426 /* Save the tag for possible task mgmt later. */
427 request->io_tag = scic_io_request_get_io_tag(
428 request->sci_request_handle);
Jeff Skirvince4f75d2011-03-31 13:10:36 -0700429 } else {
430 /* The request did not really start in the
431 * hardware, so clear the request handle
432 * here so no terminations will be done.
433 */
434 request->sci_request_handle = NULL;
Jeff Skirvinc4b9e242011-03-16 09:41:59 -0700435 }
Jeff Skirvince4f75d2011-03-31 13:10:36 -0700436
Dan Williams6f231dd2011-07-02 22:56:22 -0700437 } else
438 dev_warn(&isci_host->pdev->dev,
Jeff Skirvince4f75d2011-03-31 13:10:36 -0700439 "%s: failed request start (0x%x)\n",
440 __func__, status);
Dan Williams6f231dd2011-07-02 22:56:22 -0700441
442 spin_unlock_irqrestore(&isci_host->scic_lock, flags);
443
Jeff Skirvinc4b9e242011-03-16 09:41:59 -0700444 if (status ==
445 SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED) {
446 /* Signal libsas that we need the SCSI error
447 * handler thread to work on this I/O and that
448 * we want a device reset.
449 */
Jeff Skirvince4f75d2011-03-31 13:10:36 -0700450 spin_lock_irqsave(&task->task_state_lock, flags);
451 task->task_state_flags |= SAS_TASK_NEED_DEV_RESET;
452 spin_unlock_irqrestore(&task->task_state_lock, flags);
453
Jeff Skirvined8a72d2011-03-31 13:10:40 -0700454 /* Cause this task to be scheduled in the SCSI error
455 * handler thread.
Jeff Skirvince4f75d2011-03-31 13:10:36 -0700456 */
Jeff Skirvined8a72d2011-03-31 13:10:40 -0700457 isci_execpath_callback(isci_host, task,
458 sas_task_abort);
Jeff Skirvinc4b9e242011-03-16 09:41:59 -0700459
460 /* Change the status, since we are holding
461 * the I/O until it is managed by the SCSI
462 * error handler.
463 */
464 status = SCI_SUCCESS;
465 }
466
Dan Williams6f231dd2011-07-02 22:56:22 -0700467 } else
468 dev_warn(&isci_host->pdev->dev,
469 "%s: request_construct failed - status = 0x%x\n",
470 __func__,
471 status);
472
473 out:
474 if (status != SCI_SUCCESS) {
475
476 /* release dma memory on failure. */
477 isci_request_free(isci_host, request);
478 request = NULL;
479 ret = SCI_FAILURE;
480 }
481
482 *isci_request = request;
483 return ret;
484}
485
486
487/**
488 * isci_request_process_response_iu() - This function sets the status and
489 * response iu, in the task struct, from the request object for the upper
490 * layer driver.
491 * @sas_task: This parameter is the task struct from the upper layer driver.
492 * @resp_iu: This parameter points to the response iu of the completed request.
493 * @dev: This parameter specifies the linux device struct.
494 *
495 * none.
496 */
497static void isci_request_process_response_iu(
498 struct sas_task *task,
499 struct ssp_response_iu *resp_iu,
500 struct device *dev)
501{
502 dev_dbg(dev,
503 "%s: resp_iu = %p "
504 "resp_iu->status = 0x%x,\nresp_iu->datapres = %d "
505 "resp_iu->response_data_len = %x, "
506 "resp_iu->sense_data_len = %x\nrepsonse data: ",
507 __func__,
508 resp_iu,
509 resp_iu->status,
510 resp_iu->datapres,
511 resp_iu->response_data_len,
512 resp_iu->sense_data_len);
513
514 task->task_status.stat = resp_iu->status;
515
516 /* libsas updates the task status fields based on the response iu. */
517 sas_ssp_task_response(dev, task, resp_iu);
518}
519
520/**
521 * isci_request_set_open_reject_status() - This function prepares the I/O
522 * completion for OPEN_REJECT conditions.
523 * @request: This parameter is the completed isci_request object.
524 * @response_ptr: This parameter specifies the service response for the I/O.
525 * @status_ptr: This parameter specifies the exec status for the I/O.
526 * @complete_to_host_ptr: This parameter specifies the action to be taken by
527 * the LLDD with respect to completing this request or forcing an abort
528 * condition on the I/O.
529 * @open_rej_reason: This parameter specifies the encoded reason for the
530 * abandon-class reject.
531 *
532 * none.
533 */
534static void isci_request_set_open_reject_status(
535 struct isci_request *request,
536 struct sas_task *task,
537 enum service_response *response_ptr,
538 enum exec_status *status_ptr,
539 enum isci_completion_selection *complete_to_host_ptr,
540 enum sas_open_rej_reason open_rej_reason)
541{
542 /* Task in the target is done. */
543 request->complete_in_target = true;
544 *response_ptr = SAS_TASK_UNDELIVERED;
545 *status_ptr = SAS_OPEN_REJECT;
546 *complete_to_host_ptr = isci_perform_normal_io_completion;
547 task->task_status.open_rej_reason = open_rej_reason;
548}
549
550/**
551 * isci_request_handle_controller_specific_errors() - This function decodes
552 * controller-specific I/O completion error conditions.
553 * @request: This parameter is the completed isci_request object.
554 * @response_ptr: This parameter specifies the service response for the I/O.
555 * @status_ptr: This parameter specifies the exec status for the I/O.
556 * @complete_to_host_ptr: This parameter specifies the action to be taken by
557 * the LLDD with respect to completing this request or forcing an abort
558 * condition on the I/O.
559 *
560 * none.
561 */
562static void isci_request_handle_controller_specific_errors(
563 struct isci_remote_device *isci_device,
564 struct isci_request *request,
565 struct sas_task *task,
566 enum service_response *response_ptr,
567 enum exec_status *status_ptr,
568 enum isci_completion_selection *complete_to_host_ptr)
569{
570 unsigned int cstatus;
571
572 cstatus = scic_request_get_controller_status(
573 request->sci_request_handle
574 );
575
576 dev_dbg(&request->isci_host->pdev->dev,
577 "%s: %p SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR "
578 "- controller status = 0x%x\n",
579 __func__, request, cstatus);
580
581 /* Decode the controller-specific errors; most
582 * important is to recognize those conditions in which
583 * the target may still have a task outstanding that
584 * must be aborted.
585 *
586 * Note that there are SCU completion codes being
587 * named in the decode below for which SCIC has already
588 * done work to handle them in a way other than as
589 * a controller-specific completion code; these are left
590 * in the decode below for completeness sake.
591 */
592 switch (cstatus) {
593 case SCU_TASK_DONE_DMASETUP_DIRERR:
594 /* Also SCU_TASK_DONE_SMP_FRM_TYPE_ERR: */
595 case SCU_TASK_DONE_XFERCNT_ERR:
596 /* Also SCU_TASK_DONE_SMP_UFI_ERR: */
597 if (task->task_proto == SAS_PROTOCOL_SMP) {
598 /* SCU_TASK_DONE_SMP_UFI_ERR == Task Done. */
599 *response_ptr = SAS_TASK_COMPLETE;
600
601 /* See if the device has been/is being stopped. Note
602 * that we ignore the quiesce state, since we are
603 * concerned about the actual device state.
604 */
605 if ((isci_device->status == isci_stopping) ||
606 (isci_device->status == isci_stopped))
607 *status_ptr = SAS_DEVICE_UNKNOWN;
608 else
609 *status_ptr = SAS_ABORTED_TASK;
610
611 request->complete_in_target = true;
612
613 *complete_to_host_ptr =
614 isci_perform_normal_io_completion;
615 } else {
616 /* Task in the target is not done. */
617 *response_ptr = SAS_TASK_UNDELIVERED;
618
619 if ((isci_device->status == isci_stopping) ||
620 (isci_device->status == isci_stopped))
621 *status_ptr = SAS_DEVICE_UNKNOWN;
622 else
623 *status_ptr = SAM_STAT_TASK_ABORTED;
624
625 request->complete_in_target = false;
626
627 *complete_to_host_ptr =
628 isci_perform_error_io_completion;
629 }
630
631 break;
632
633 case SCU_TASK_DONE_CRC_ERR:
634 case SCU_TASK_DONE_NAK_CMD_ERR:
635 case SCU_TASK_DONE_EXCESS_DATA:
636 case SCU_TASK_DONE_UNEXP_FIS:
637 /* Also SCU_TASK_DONE_UNEXP_RESP: */
638 case SCU_TASK_DONE_VIIT_ENTRY_NV: /* TODO - conditions? */
639 case SCU_TASK_DONE_IIT_ENTRY_NV: /* TODO - conditions? */
640 case SCU_TASK_DONE_RNCNV_OUTBOUND: /* TODO - conditions? */
641 /* These are conditions in which the target
642 * has completed the task, so that no cleanup
643 * is necessary.
644 */
645 *response_ptr = SAS_TASK_COMPLETE;
646
647 /* See if the device has been/is being stopped. Note
648 * that we ignore the quiesce state, since we are
649 * concerned about the actual device state.
650 */
651 if ((isci_device->status == isci_stopping) ||
652 (isci_device->status == isci_stopped))
653 *status_ptr = SAS_DEVICE_UNKNOWN;
654 else
655 *status_ptr = SAS_ABORTED_TASK;
656
657 request->complete_in_target = true;
658
659 *complete_to_host_ptr = isci_perform_normal_io_completion;
660 break;
661
662
663 /* Note that the only open reject completion codes seen here will be
664 * abandon-class codes; all others are automatically retried in the SCU.
665 */
666 case SCU_TASK_OPEN_REJECT_WRONG_DESTINATION:
667
668 isci_request_set_open_reject_status(
669 request, task, response_ptr, status_ptr,
670 complete_to_host_ptr, SAS_OREJ_WRONG_DEST);
671 break;
672
673 case SCU_TASK_OPEN_REJECT_ZONE_VIOLATION:
674
675 /* Note - the return of AB0 will change when
676 * libsas implements detection of zone violations.
677 */
678 isci_request_set_open_reject_status(
679 request, task, response_ptr, status_ptr,
680 complete_to_host_ptr, SAS_OREJ_RESV_AB0);
681 break;
682
683 case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_1:
684
685 isci_request_set_open_reject_status(
686 request, task, response_ptr, status_ptr,
687 complete_to_host_ptr, SAS_OREJ_RESV_AB1);
688 break;
689
690 case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_2:
691
692 isci_request_set_open_reject_status(
693 request, task, response_ptr, status_ptr,
694 complete_to_host_ptr, SAS_OREJ_RESV_AB2);
695 break;
696
697 case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_3:
698
699 isci_request_set_open_reject_status(
700 request, task, response_ptr, status_ptr,
701 complete_to_host_ptr, SAS_OREJ_RESV_AB3);
702 break;
703
704 case SCU_TASK_OPEN_REJECT_BAD_DESTINATION:
705
706 isci_request_set_open_reject_status(
707 request, task, response_ptr, status_ptr,
708 complete_to_host_ptr, SAS_OREJ_BAD_DEST);
709 break;
710
711 case SCU_TASK_OPEN_REJECT_STP_RESOURCES_BUSY:
712
713 isci_request_set_open_reject_status(
714 request, task, response_ptr, status_ptr,
715 complete_to_host_ptr, SAS_OREJ_STP_NORES);
716 break;
717
718 case SCU_TASK_OPEN_REJECT_PROTOCOL_NOT_SUPPORTED:
719
720 isci_request_set_open_reject_status(
721 request, task, response_ptr, status_ptr,
722 complete_to_host_ptr, SAS_OREJ_EPROTO);
723 break;
724
725 case SCU_TASK_OPEN_REJECT_CONNECTION_RATE_NOT_SUPPORTED:
726
727 isci_request_set_open_reject_status(
728 request, task, response_ptr, status_ptr,
729 complete_to_host_ptr, SAS_OREJ_CONN_RATE);
730 break;
731
732 case SCU_TASK_DONE_LL_R_ERR:
733 /* Also SCU_TASK_DONE_ACK_NAK_TO: */
734 case SCU_TASK_DONE_LL_PERR:
735 case SCU_TASK_DONE_LL_SY_TERM:
736 /* Also SCU_TASK_DONE_NAK_ERR:*/
737 case SCU_TASK_DONE_LL_LF_TERM:
738 /* Also SCU_TASK_DONE_DATA_LEN_ERR: */
739 case SCU_TASK_DONE_LL_ABORT_ERR:
740 case SCU_TASK_DONE_SEQ_INV_TYPE:
741 /* Also SCU_TASK_DONE_UNEXP_XR: */
742 case SCU_TASK_DONE_XR_IU_LEN_ERR:
743 case SCU_TASK_DONE_INV_FIS_LEN:
744 /* Also SCU_TASK_DONE_XR_WD_LEN: */
745 case SCU_TASK_DONE_SDMA_ERR:
746 case SCU_TASK_DONE_OFFSET_ERR:
747 case SCU_TASK_DONE_MAX_PLD_ERR:
748 case SCU_TASK_DONE_LF_ERR:
749 case SCU_TASK_DONE_SMP_RESP_TO_ERR: /* Escalate to dev reset? */
750 case SCU_TASK_DONE_SMP_LL_RX_ERR:
751 case SCU_TASK_DONE_UNEXP_DATA:
752 case SCU_TASK_DONE_UNEXP_SDBFIS:
753 case SCU_TASK_DONE_REG_ERR:
754 case SCU_TASK_DONE_SDB_ERR:
755 case SCU_TASK_DONE_TASK_ABORT:
756 default:
757 /* Task in the target is not done. */
758 *response_ptr = SAS_TASK_UNDELIVERED;
759 *status_ptr = SAM_STAT_TASK_ABORTED;
760 request->complete_in_target = false;
761
762 *complete_to_host_ptr = isci_perform_error_io_completion;
763 break;
764 }
765}
766
767/**
768 * isci_task_save_for_upper_layer_completion() - This function saves the
769 * request for later completion to the upper layer driver.
770 * @host: This parameter is a pointer to the host on which the the request
771 * should be queued (either as an error or success).
772 * @request: This parameter is the completed request.
773 * @response: This parameter is the response code for the completed task.
774 * @status: This parameter is the status code for the completed task.
775 *
776 * none.
777 */
778static void isci_task_save_for_upper_layer_completion(
779 struct isci_host *host,
780 struct isci_request *request,
781 enum service_response response,
782 enum exec_status status,
783 enum isci_completion_selection task_notification_selection)
784{
785 struct sas_task *task = isci_request_access_task(request);
786
Jeff Skirvinec6c9632011-03-04 14:06:44 -0800787 task_notification_selection
788 = isci_task_set_completion_status(task, response, status,
789 task_notification_selection);
Dan Williams6f231dd2011-07-02 22:56:22 -0700790
791 /* Tasks aborted specifically by a call to the lldd_abort_task
792 * function should not be completed to the host in the regular path.
793 */
794 switch (task_notification_selection) {
795
796 case isci_perform_normal_io_completion:
797
798 /* Normal notification (task_done) */
799 dev_dbg(&host->pdev->dev,
Jeff Skirvinaa145102011-03-07 16:40:47 -0700800 "%s: Normal - task = %p, response=%d (%d), status=%d (%d)\n",
Dan Williams6f231dd2011-07-02 22:56:22 -0700801 __func__,
802 task,
Jeff Skirvinaa145102011-03-07 16:40:47 -0700803 task->task_status.resp, response,
804 task->task_status.stat, status);
Dan Williams6f231dd2011-07-02 22:56:22 -0700805 /* Add to the completed list. */
806 list_add(&request->completed_node,
807 &host->requests_to_complete);
Jeff Skirvinec6c9632011-03-04 14:06:44 -0800808
809 /* Take the request off the device's pending request list. */
810 list_del_init(&request->dev_node);
Dan Williams6f231dd2011-07-02 22:56:22 -0700811 break;
812
813 case isci_perform_aborted_io_completion:
Jeff Skirvina5fde222011-03-04 14:06:42 -0800814 /* No notification to libsas because this request is
815 * already in the abort path.
Dan Williams6f231dd2011-07-02 22:56:22 -0700816 */
817 dev_warn(&host->pdev->dev,
Jeff Skirvinaa145102011-03-07 16:40:47 -0700818 "%s: Aborted - task = %p, response=%d (%d), status=%d (%d)\n",
Dan Williams6f231dd2011-07-02 22:56:22 -0700819 __func__,
820 task,
Jeff Skirvinaa145102011-03-07 16:40:47 -0700821 task->task_status.resp, response,
822 task->task_status.stat, status);
Jeff Skirvina5fde222011-03-04 14:06:42 -0800823
824 /* Wake up whatever process was waiting for this
825 * request to complete.
826 */
827 WARN_ON(request->io_request_completion == NULL);
828
829 if (request->io_request_completion != NULL) {
830
831 /* Signal whoever is waiting that this
832 * request is complete.
833 */
834 complete(request->io_request_completion);
835 }
Dan Williams6f231dd2011-07-02 22:56:22 -0700836 break;
837
838 case isci_perform_error_io_completion:
839 /* Use sas_task_abort */
840 dev_warn(&host->pdev->dev,
Jeff Skirvinaa145102011-03-07 16:40:47 -0700841 "%s: Error - task = %p, response=%d (%d), status=%d (%d)\n",
Dan Williams6f231dd2011-07-02 22:56:22 -0700842 __func__,
843 task,
Jeff Skirvinaa145102011-03-07 16:40:47 -0700844 task->task_status.resp, response,
845 task->task_status.stat, status);
Dan Williams6f231dd2011-07-02 22:56:22 -0700846 /* Add to the aborted list. */
847 list_add(&request->completed_node,
Jeff Skirvin11b00c12011-03-04 14:06:40 -0800848 &host->requests_to_errorback);
Dan Williams6f231dd2011-07-02 22:56:22 -0700849 break;
850
851 default:
852 dev_warn(&host->pdev->dev,
Jeff Skirvinaa145102011-03-07 16:40:47 -0700853 "%s: Unknown - task = %p, response=%d (%d), status=%d (%d)\n",
Dan Williams6f231dd2011-07-02 22:56:22 -0700854 __func__,
855 task,
Jeff Skirvinaa145102011-03-07 16:40:47 -0700856 task->task_status.resp, response,
857 task->task_status.stat, status);
Dan Williams6f231dd2011-07-02 22:56:22 -0700858
Jeff Skirvina5fde222011-03-04 14:06:42 -0800859 /* Add to the error to libsas list. */
Dan Williams6f231dd2011-07-02 22:56:22 -0700860 list_add(&request->completed_node,
Jeff Skirvin11b00c12011-03-04 14:06:40 -0800861 &host->requests_to_errorback);
Dan Williams6f231dd2011-07-02 22:56:22 -0700862 break;
863 }
864}
865
866/**
867 * isci_request_io_request_complete() - This function is called by the sci core
868 * when an io request completes.
869 * @isci_host: This parameter specifies the ISCI host object
870 * @request: This parameter is the completed isci_request object.
871 * @completion_status: This parameter specifies the completion status from the
872 * sci core.
873 *
874 * none.
875 */
876void isci_request_io_request_complete(
877 struct isci_host *isci_host,
878 struct isci_request *request,
879 enum sci_io_status completion_status)
880{
881 struct sas_task *task = isci_request_access_task(request);
882 struct ssp_response_iu *resp_iu;
883 void *resp_buf;
884 unsigned long task_flags;
Dan Williams6f231dd2011-07-02 22:56:22 -0700885 struct isci_remote_device *isci_device = request->isci_device;
886 enum service_response response = SAS_TASK_UNDELIVERED;
887 enum exec_status status = SAS_ABORTED_TASK;
888 enum isci_request_status request_status;
889 enum isci_completion_selection complete_to_host
890 = isci_perform_normal_io_completion;
891
892 dev_dbg(&isci_host->pdev->dev,
893 "%s: request = %p, task = %p,\n"
894 "task->data_dir = %d completion_status = 0x%x\n",
895 __func__,
896 request,
897 task,
898 task->data_dir,
899 completion_status);
900
Jeff Skirvina5fde222011-03-04 14:06:42 -0800901 spin_lock(&request->state_lock);
Dan Williams6f231dd2011-07-02 22:56:22 -0700902 request_status = isci_request_get_state(request);
Dan Williams6f231dd2011-07-02 22:56:22 -0700903
904 /* Decode the request status. Note that if the request has been
905 * aborted by a task management function, we don't care
906 * what the status is.
907 */
908 switch (request_status) {
909
910 case aborted:
911 /* "aborted" indicates that the request was aborted by a task
912 * management function, since once a task management request is
913 * perfomed by the device, the request only completes because
914 * of the subsequent driver terminate.
915 *
916 * Aborted also means an external thread is explicitly managing
917 * this request, so that we do not complete it up the stack.
918 *
919 * The target is still there (since the TMF was successful).
920 */
921 request->complete_in_target = true;
922 response = SAS_TASK_COMPLETE;
923
924 /* See if the device has been/is being stopped. Note
925 * that we ignore the quiesce state, since we are
926 * concerned about the actual device state.
927 */
928 if ((isci_device->status == isci_stopping)
929 || (isci_device->status == isci_stopped)
930 )
931 status = SAS_DEVICE_UNKNOWN;
932 else
933 status = SAS_ABORTED_TASK;
934
935 complete_to_host = isci_perform_aborted_io_completion;
936 /* This was an aborted request. */
Jeff Skirvina5fde222011-03-04 14:06:42 -0800937
938 spin_unlock(&request->state_lock);
Dan Williams6f231dd2011-07-02 22:56:22 -0700939 break;
940
941 case aborting:
942 /* aborting means that the task management function tried and
943 * failed to abort the request. We need to note the request
944 * as SAS_TASK_UNDELIVERED, so that the scsi mid layer marks the
945 * target as down.
946 *
947 * Aborting also means an external thread is explicitly managing
948 * this request, so that we do not complete it up the stack.
949 */
950 request->complete_in_target = true;
951 response = SAS_TASK_UNDELIVERED;
952
953 if ((isci_device->status == isci_stopping) ||
954 (isci_device->status == isci_stopped))
955 /* The device has been /is being stopped. Note that
956 * we ignore the quiesce state, since we are
957 * concerned about the actual device state.
958 */
959 status = SAS_DEVICE_UNKNOWN;
960 else
961 status = SAS_PHY_DOWN;
962
963 complete_to_host = isci_perform_aborted_io_completion;
964
965 /* This was an aborted request. */
Jeff Skirvina5fde222011-03-04 14:06:42 -0800966
967 spin_unlock(&request->state_lock);
Dan Williams6f231dd2011-07-02 22:56:22 -0700968 break;
969
970 case terminating:
971
972 /* This was an terminated request. This happens when
973 * the I/O is being terminated because of an action on
974 * the device (reset, tear down, etc.), and the I/O needs
975 * to be completed up the stack.
976 */
977 request->complete_in_target = true;
978 response = SAS_TASK_UNDELIVERED;
979
980 /* See if the device has been/is being stopped. Note
981 * that we ignore the quiesce state, since we are
982 * concerned about the actual device state.
983 */
984 if ((isci_device->status == isci_stopping) ||
985 (isci_device->status == isci_stopped))
986 status = SAS_DEVICE_UNKNOWN;
987 else
988 status = SAS_ABORTED_TASK;
989
Jeff Skirvina5fde222011-03-04 14:06:42 -0800990 complete_to_host = isci_perform_aborted_io_completion;
Dan Williams6f231dd2011-07-02 22:56:22 -0700991
992 /* This was a terminated request. */
Jeff Skirvina5fde222011-03-04 14:06:42 -0800993
994 spin_unlock(&request->state_lock);
Dan Williams6f231dd2011-07-02 22:56:22 -0700995 break;
996
997 default:
998
Jeff Skirvina5fde222011-03-04 14:06:42 -0800999 /* The request is done from an SCU HW perspective. */
1000 request->status = completed;
1001
1002 spin_unlock(&request->state_lock);
1003
Dan Williams6f231dd2011-07-02 22:56:22 -07001004 /* This is an active request being completed from the core. */
1005 switch (completion_status) {
1006
1007 case SCI_IO_FAILURE_RESPONSE_VALID:
1008 dev_dbg(&isci_host->pdev->dev,
1009 "%s: SCI_IO_FAILURE_RESPONSE_VALID (%p/%p)\n",
1010 __func__,
1011 request,
1012 task);
1013
1014 if (sas_protocol_ata(task->task_proto)) {
1015 resp_buf
1016 = scic_stp_io_request_get_d2h_reg_address(
1017 request->sci_request_handle
1018 );
1019 isci_request_process_stp_response(task,
1020 resp_buf
1021 );
1022
1023 } else if (SAS_PROTOCOL_SSP == task->task_proto) {
1024
1025 /* crack the iu response buffer. */
1026 resp_iu
1027 = scic_io_request_get_response_iu_address(
1028 request->sci_request_handle
1029 );
1030
1031 isci_request_process_response_iu(task, resp_iu,
1032 &isci_host->pdev->dev
1033 );
1034
1035 } else if (SAS_PROTOCOL_SMP == task->task_proto) {
1036
1037 dev_err(&isci_host->pdev->dev,
1038 "%s: SCI_IO_FAILURE_RESPONSE_VALID: "
1039 "SAS_PROTOCOL_SMP protocol\n",
1040 __func__);
1041
1042 } else
1043 dev_err(&isci_host->pdev->dev,
1044 "%s: unknown protocol\n", __func__);
1045
1046 /* use the task status set in the task struct by the
1047 * isci_request_process_response_iu call.
1048 */
1049 request->complete_in_target = true;
1050 response = task->task_status.resp;
1051 status = task->task_status.stat;
1052 break;
1053
1054 case SCI_IO_SUCCESS:
1055 case SCI_IO_SUCCESS_IO_DONE_EARLY:
1056
1057 response = SAS_TASK_COMPLETE;
1058 status = SAM_STAT_GOOD;
1059 request->complete_in_target = true;
1060
1061 if (task->task_proto == SAS_PROTOCOL_SMP) {
1062
1063 u8 *command_iu_address
1064 = scic_io_request_get_command_iu_address(
1065 request->sci_request_handle
1066 );
1067
1068 dev_dbg(&isci_host->pdev->dev,
1069 "%s: SMP protocol completion\n",
1070 __func__);
1071
1072 sg_copy_from_buffer(
1073 &task->smp_task.smp_resp, 1,
1074 command_iu_address
1075 + sizeof(struct smp_request),
1076 sizeof(struct smp_resp)
1077 );
1078 } else if (completion_status
1079 == SCI_IO_SUCCESS_IO_DONE_EARLY) {
1080
1081 /* This was an SSP / STP / SATA transfer.
1082 * There is a possibility that less data than
1083 * the maximum was transferred.
1084 */
1085 u32 transferred_length
1086 = scic_io_request_get_number_of_bytes_transferred(
1087 request->sci_request_handle);
1088
1089 task->task_status.residual
1090 = task->total_xfer_len - transferred_length;
1091
1092 /* If there were residual bytes, call this an
1093 * underrun.
1094 */
1095 if (task->task_status.residual != 0)
1096 status = SAS_DATA_UNDERRUN;
1097
1098 dev_dbg(&isci_host->pdev->dev,
1099 "%s: SCI_IO_SUCCESS_IO_DONE_EARLY %d\n",
1100 __func__,
1101 status);
1102
1103 } else
1104 dev_dbg(&isci_host->pdev->dev,
1105 "%s: SCI_IO_SUCCESS\n",
1106 __func__);
1107
1108 break;
1109
1110 case SCI_IO_FAILURE_TERMINATED:
1111 dev_dbg(&isci_host->pdev->dev,
1112 "%s: SCI_IO_FAILURE_TERMINATED (%p/%p)\n",
1113 __func__,
1114 request,
1115 task);
1116
1117 /* The request was terminated explicitly. No handling
1118 * is needed in the SCSI error handler path.
1119 */
1120 request->complete_in_target = true;
1121 response = SAS_TASK_UNDELIVERED;
1122
1123 /* See if the device has been/is being stopped. Note
1124 * that we ignore the quiesce state, since we are
1125 * concerned about the actual device state.
1126 */
1127 if ((isci_device->status == isci_stopping) ||
1128 (isci_device->status == isci_stopped))
1129 status = SAS_DEVICE_UNKNOWN;
1130 else
1131 status = SAS_ABORTED_TASK;
1132
1133 complete_to_host = isci_perform_normal_io_completion;
1134 break;
1135
1136 case SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR:
1137
1138 isci_request_handle_controller_specific_errors(
1139 isci_device, request, task, &response, &status,
1140 &complete_to_host);
1141
1142 break;
1143
1144 case SCI_IO_FAILURE_REMOTE_DEVICE_RESET_REQUIRED:
1145 /* This is a special case, in that the I/O completion
1146 * is telling us that the device needs a reset.
1147 * In order for the device reset condition to be
1148 * noticed, the I/O has to be handled in the error
1149 * handler. Set the reset flag and cause the
1150 * SCSI error thread to be scheduled.
1151 */
1152 spin_lock_irqsave(&task->task_state_lock, task_flags);
1153 task->task_state_flags |= SAS_TASK_NEED_DEV_RESET;
1154 spin_unlock_irqrestore(&task->task_state_lock, task_flags);
1155
Jeff Skirvinaa145102011-03-07 16:40:47 -07001156 /* Fail the I/O. */
1157 response = SAS_TASK_UNDELIVERED;
1158 status = SAM_STAT_TASK_ABORTED;
1159
Dan Williams6f231dd2011-07-02 22:56:22 -07001160 complete_to_host = isci_perform_error_io_completion;
1161 request->complete_in_target = false;
1162 break;
1163
1164 default:
1165 /* Catch any otherwise unhandled error codes here. */
1166 dev_warn(&isci_host->pdev->dev,
1167 "%s: invalid completion code: 0x%x - "
1168 "isci_request = %p\n",
1169 __func__, completion_status, request);
1170
1171 response = SAS_TASK_UNDELIVERED;
1172
1173 /* See if the device has been/is being stopped. Note
1174 * that we ignore the quiesce state, since we are
1175 * concerned about the actual device state.
1176 */
1177 if ((isci_device->status == isci_stopping) ||
1178 (isci_device->status == isci_stopped))
1179 status = SAS_DEVICE_UNKNOWN;
1180 else
1181 status = SAS_ABORTED_TASK;
1182
1183 complete_to_host = isci_perform_error_io_completion;
1184 request->complete_in_target = false;
1185 break;
1186 }
1187 break;
1188 }
1189
1190 isci_request_unmap_sgl(request, isci_host->pdev);
1191
1192 /* Put the completed request on the correct list */
1193 isci_task_save_for_upper_layer_completion(isci_host, request, response,
1194 status, complete_to_host
1195 );
1196
1197 /* complete the io request to the core. */
1198 scic_controller_complete_io(
1199 isci_host->core_controller,
Dan Williams3a97eec2011-03-04 11:51:43 -08001200 to_sci_dev(isci_device),
Dan Williams6f231dd2011-07-02 22:56:22 -07001201 request->sci_request_handle
1202 );
1203 /* NULL the request handle so it cannot be completed or
1204 * terminated again, and to cause any calls into abort
1205 * task to recognize the already completed case.
1206 */
1207 request->sci_request_handle = NULL;
1208
Dan Williams6f231dd2011-07-02 22:56:22 -07001209 isci_host_can_dequeue(isci_host, 1);
1210}
1211
1212/**
1213 * isci_request_io_request_get_transfer_length() - This function is called by
1214 * the sci core to retrieve the transfer length for a given request.
1215 * @request: This parameter is the isci_request object.
1216 *
1217 * length of transfer for specified request.
1218 */
1219u32 isci_request_io_request_get_transfer_length(struct isci_request *request)
1220{
1221 struct sas_task *task = isci_request_access_task(request);
1222
1223 dev_dbg(&request->isci_host->pdev->dev,
1224 "%s: total_xfer_len: %d\n",
1225 __func__,
1226 task->total_xfer_len);
1227 return task->total_xfer_len;
1228}
1229
1230
1231/**
1232 * isci_request_io_request_get_data_direction() - This function is called by
1233 * the sci core to retrieve the data direction for a given request.
1234 * @request: This parameter is the isci_request object.
1235 *
1236 * data direction for specified request.
1237 */
Dan Williams82d29922011-02-08 17:53:10 -08001238enum dma_data_direction isci_request_io_request_get_data_direction(
Dan Williams6f231dd2011-07-02 22:56:22 -07001239 struct isci_request *request)
1240{
1241 struct sas_task *task = isci_request_access_task(request);
Dan Williams6f231dd2011-07-02 22:56:22 -07001242
Dan Williams82d29922011-02-08 17:53:10 -08001243 return task->data_dir;
Dan Williams6f231dd2011-07-02 22:56:22 -07001244}
1245
1246/**
1247 * isci_request_sge_get_address_field() - This function is called by the sci
1248 * core to retrieve the address field contents for a given sge.
1249 * @request: This parameter is the isci_request object.
1250 * @sge_address: This parameter is the sge.
1251 *
1252 * physical address in the specified sge.
1253 */
Dan Williams6f231dd2011-07-02 22:56:22 -07001254
1255
1256/**
1257 * isci_request_sge_get_length_field() - This function is called by the sci
1258 * core to retrieve the length field contents for a given sge.
1259 * @request: This parameter is the isci_request object.
1260 * @sge_address: This parameter is the sge.
1261 *
1262 * length field value in the specified sge.
1263 */
Dan Williams6f231dd2011-07-02 22:56:22 -07001264
1265
1266/**
1267 * isci_request_ssp_io_request_get_cdb_address() - This function is called by
1268 * the sci core to retrieve the cdb address for a given request.
1269 * @request: This parameter is the isci_request object.
1270 *
1271 * cdb address for specified request.
1272 */
1273void *isci_request_ssp_io_request_get_cdb_address(
1274 struct isci_request *request)
1275{
1276 struct sas_task *task = isci_request_access_task(request);
1277
1278 dev_dbg(&request->isci_host->pdev->dev,
1279 "%s: request->task->ssp_task.cdb = %p\n",
1280 __func__,
1281 task->ssp_task.cdb);
1282 return task->ssp_task.cdb;
1283}
1284
1285
1286/**
1287 * isci_request_ssp_io_request_get_cdb_length() - This function is called by
1288 * the sci core to retrieve the cdb length for a given request.
1289 * @request: This parameter is the isci_request object.
1290 *
1291 * cdb length for specified request.
1292 */
1293u32 isci_request_ssp_io_request_get_cdb_length(
1294 struct isci_request *request)
1295{
1296 return 16;
1297}
1298
1299
1300/**
1301 * isci_request_ssp_io_request_get_lun() - This function is called by the sci
1302 * core to retrieve the lun for a given request.
1303 * @request: This parameter is the isci_request object.
1304 *
1305 * lun for specified request.
1306 */
1307u32 isci_request_ssp_io_request_get_lun(
1308 struct isci_request *request)
1309{
1310 struct sas_task *task = isci_request_access_task(request);
1311
1312#ifdef DEBUG
1313 int i;
1314
1315 for (i = 0; i < 8; i++)
1316 dev_dbg(&request->isci_host->pdev->dev,
Dan Williams83f5eee2011-02-18 09:25:15 -08001317 "%s: task->ssp_task.LUN[%d] = %x\n",
1318 __func__, i, task->ssp_task.LUN[i]);
Dan Williams6f231dd2011-07-02 22:56:22 -07001319
1320#endif
1321
1322 return task->ssp_task.LUN[0];
1323}
1324
1325
1326/**
1327 * isci_request_ssp_io_request_get_task_attribute() - This function is called
1328 * by the sci core to retrieve the task attribute for a given request.
1329 * @request: This parameter is the isci_request object.
1330 *
1331 * task attribute for specified request.
1332 */
1333u32 isci_request_ssp_io_request_get_task_attribute(
1334 struct isci_request *request)
1335{
1336 struct sas_task *task = isci_request_access_task(request);
1337
1338 dev_dbg(&request->isci_host->pdev->dev,
1339 "%s: request->task->ssp_task.task_attr = %x\n",
1340 __func__,
1341 task->ssp_task.task_attr);
1342
1343 return task->ssp_task.task_attr;
1344}
1345
1346
1347/**
1348 * isci_request_ssp_io_request_get_command_priority() - This function is called
1349 * by the sci core to retrieve the command priority for a given request.
1350 * @request: This parameter is the isci_request object.
1351 *
1352 * command priority for specified request.
1353 */
1354u32 isci_request_ssp_io_request_get_command_priority(
1355 struct isci_request *request)
1356{
1357 struct sas_task *task = isci_request_access_task(request);
1358
1359 dev_dbg(&request->isci_host->pdev->dev,
1360 "%s: request->task->ssp_task.task_prio = %x\n",
1361 __func__,
1362 task->ssp_task.task_prio);
1363
1364 return task->ssp_task.task_prio;
1365}