?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
isci: merge smp request substates into primary state machine
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / scsi / isci / stp_request.c
blobe94ece81ed9d7759baf7a679a649945ca652af87
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
56 #include <scsi/sas.h>
57 #include "sas.h"
58 #include "state_machine.h"
59 #include "remote_device.h"
60 #include "stp_request.h"
61 #include "unsolicited_frame_control.h"
62 #include "scu_completion_codes.h"
63 #include "scu_event_codes.h"
64 #include "scu_task_context.h"
65 #include "request.h"
66
67 /**
68 * This method is will fill in the SCU Task Context for any type of SATA
69 * request. This is called from the various SATA constructors.
70 * @sci_req: The general IO request object which is to be used in
71 * constructing the SCU task context.
72 * @task_context: The buffer pointer for the SCU task context which is being
73 * constructed.
74 *
75 * The general io request construction is complete. The buffer assignment for
76 * the command buffer is complete. none Revisit task context construction to
77 * determine what is common for SSP/SMP/STP task context structures.
78 */
79 static void scu_sata_reqeust_construct_task_context(
80 struct scic_sds_request *sci_req,
81 struct scu_task_context *task_context)
82 {
83 dma_addr_t dma_addr;
84 struct scic_sds_controller *controller;
85 struct scic_sds_remote_device *target_device;
86 struct scic_sds_port *target_port;
87
88 controller = scic_sds_request_get_controller(sci_req);
89 target_device = scic_sds_request_get_device(sci_req);
90 target_port = scic_sds_request_get_port(sci_req);
91
92 /* Fill in the TC with the its required data */
93 task_context->abort = 0;
94 task_context->priority = SCU_TASK_PRIORITY_NORMAL;
95 task_context->initiator_request = 1;
96 task_context->connection_rate = target_device->connection_rate;
97 task_context->protocol_engine_index =
98 scic_sds_controller_get_protocol_engine_group(controller);
99 task_context->logical_port_index =
100 scic_sds_port_get_index(target_port);
101 task_context->protocol_type = SCU_TASK_CONTEXT_PROTOCOL_STP;
102 task_context->valid = SCU_TASK_CONTEXT_VALID;
103 task_context->context_type = SCU_TASK_CONTEXT_TYPE;
104
105 task_context->remote_node_index =
106 scic_sds_remote_device_get_index(sci_req->target_device);
107 task_context->command_code = 0;
108
109 task_context->link_layer_control = 0;
110 task_context->do_not_dma_ssp_good_response = 1;
111 task_context->strict_ordering = 0;
112 task_context->control_frame = 0;
113 task_context->timeout_enable = 0;
114 task_context->block_guard_enable = 0;
115
116 task_context->address_modifier = 0;
117 task_context->task_phase = 0x01;
118
119 task_context->ssp_command_iu_length =
120 (sizeof(struct host_to_dev_fis) - sizeof(u32)) / sizeof(u32);
121
122 /* Set the first word of the H2D REG FIS */
123 task_context->type.words[0] = *(u32 *)&sci_req->stp.cmd;
124
125 if (sci_req->was_tag_assigned_by_user) {
126 /*
127 * Build the task context now since we have already read
128 * the data
129 */
130 sci_req->post_context =
131 (SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC |
132 (scic_sds_controller_get_protocol_engine_group(
133 controller) <<
134 SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_SHIFT) |
135 (scic_sds_port_get_index(target_port) <<
136 SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT) |
137 scic_sds_io_tag_get_index(sci_req->io_tag));
138 } else {
139 /*
140 * Build the task context now since we have already read
141 * the data.
142 * I/O tag index is not assigned because we have to wait
143 * until we get a TCi.
144 */
145 sci_req->post_context =
146 (SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC |
147 (scic_sds_controller_get_protocol_engine_group(
148 controller) <<
149 SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_SHIFT) |
150 (scic_sds_port_get_index(target_port) <<
151 SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT));
152 }
153
154 /*
155 * Copy the physical address for the command buffer to the SCU Task
156 * Context. We must offset the command buffer by 4 bytes because the
157 * first 4 bytes are transfered in the body of the TC.
158 */
159 dma_addr = scic_io_request_get_dma_addr(sci_req,
160 ((char *) &sci_req->stp.cmd) +
161 sizeof(u32));
162
163 task_context->command_iu_upper = upper_32_bits(dma_addr);
164 task_context->command_iu_lower = lower_32_bits(dma_addr);
165
166 /* SATA Requests do not have a response buffer */
167 task_context->response_iu_upper = 0;
168 task_context->response_iu_lower = 0;
169 }
170
171 /**
172 *
173 * @sci_req:
174 *
175 * This method will perform any general sata request construction. What part of
176 * SATA IO request construction is general? none
177 */
178 static void scic_sds_stp_non_ncq_request_construct(
179 struct scic_sds_request *sci_req)
180 {
181 sci_req->has_started_substate_machine = true;
182 }
183
184 /**
185 *
186 * @sci_req: This parameter specifies the request to be constructed as an
187 * optimized request.
188 * @optimized_task_type: This parameter specifies whether the request is to be
189 * an UDMA request or a NCQ request. - A value of 0 indicates UDMA. - A
190 * value of 1 indicates NCQ.
191 *
192 * This method will perform request construction common to all types of STP
193 * requests that are optimized by the silicon (i.e. UDMA, NCQ). This method
194 * returns an indication as to whether the construction was successful.
195 */
196 static void scic_sds_stp_optimized_request_construct(struct scic_sds_request *sci_req,
197 u8 optimized_task_type,
198 u32 len,
199 enum dma_data_direction dir)
200 {
201 struct scu_task_context *task_context = sci_req->task_context_buffer;
202
203 /* Build the STP task context structure */
204 scu_sata_reqeust_construct_task_context(sci_req, task_context);
205
206 /* Copy over the SGL elements */
207 scic_sds_request_build_sgl(sci_req);
208
209 /* Copy over the number of bytes to be transfered */
210 task_context->transfer_length_bytes = len;
211
212 if (dir == DMA_TO_DEVICE) {
213 /*
214 * The difference between the DMA IN and DMA OUT request task type
215 * values are consistent with the difference between FPDMA READ
216 * and FPDMA WRITE values. Add the supplied task type parameter
217 * to this difference to set the task type properly for this
218 * DATA OUT (WRITE) case. */
219 task_context->task_type = optimized_task_type + (SCU_TASK_TYPE_DMA_OUT
220 - SCU_TASK_TYPE_DMA_IN);
221 } else {
222 /*
223 * For the DATA IN (READ) case, simply save the supplied
224 * optimized task type. */
225 task_context->task_type = optimized_task_type;
226 }
227 }
228
229 /**
230 *
231 * @sci_req: This parameter specifies the request to be constructed.
232 *
233 * This method will construct the STP UDMA request and its associated TC data.
234 * This method returns an indication as to whether the construction was
235 * successful. SCI_SUCCESS Currently this method always returns this value.
236 */
237 enum sci_status scic_sds_stp_ncq_request_construct(struct scic_sds_request *sci_req,
238 u32 len,
239 enum dma_data_direction dir)
240 {
241 scic_sds_stp_optimized_request_construct(sci_req,
242 SCU_TASK_TYPE_FPDMAQ_READ,
243 len, dir);
244 return SCI_SUCCESS;
245 }
246
247 /**
248 * scu_stp_raw_request_construct_task_context -
249 * @sci_req: This parameter specifies the STP request object for which to
250 * construct a RAW command frame task context.
251 * @task_context: This parameter specifies the SCU specific task context buffer
252 * to construct.
253 *
254 * This method performs the operations common to all SATA/STP requests
255 * utilizing the raw frame method. none
256 */
257 static void scu_stp_raw_request_construct_task_context(
258 struct scic_sds_stp_request *stp_req,
259 struct scu_task_context *task_context)
260 {
261 struct scic_sds_request *sci_req = to_sci_req(stp_req);
262
263 scu_sata_reqeust_construct_task_context(sci_req, task_context);
264
265 task_context->control_frame = 0;
266 task_context->priority = SCU_TASK_PRIORITY_NORMAL;
267 task_context->task_type = SCU_TASK_TYPE_SATA_RAW_FRAME;
268 task_context->type.stp.fis_type = FIS_REGH2D;
269 task_context->transfer_length_bytes = sizeof(struct host_to_dev_fis) - sizeof(u32);
270 }
271
272 void scic_stp_io_request_set_ncq_tag(
273 struct scic_sds_request *req,
274 u16 ncq_tag)
275 {
276 /**
277 * @note This could be made to return an error to the user if the user
278 * attempts to set the NCQ tag in the wrong state.
279 */
280 req->task_context_buffer->type.stp.ncq_tag = ncq_tag;
281 }
282
283 /**
284 *
285 * @sci_req:
286 *
287 * Get the next SGL element from the request. - Check on which SGL element pair
288 * we are working - if working on SLG pair element A - advance to element B -
289 * else - check to see if there are more SGL element pairs for this IO request
290 * - if there are more SGL element pairs - advance to the next pair and return
291 * element A struct scu_sgl_element*
292 */
293 static struct scu_sgl_element *scic_sds_stp_request_pio_get_next_sgl(struct scic_sds_stp_request *stp_req)
294 {
295 struct scu_sgl_element *current_sgl;
296 struct scic_sds_request *sci_req = to_sci_req(stp_req);
297 struct scic_sds_request_pio_sgl *pio_sgl = &stp_req->type.pio.request_current;
298
299 if (pio_sgl->sgl_set == SCU_SGL_ELEMENT_PAIR_A) {
300 if (pio_sgl->sgl_pair->B.address_lower == 0 &&
301 pio_sgl->sgl_pair->B.address_upper == 0) {
302 current_sgl = NULL;
303 } else {
304 pio_sgl->sgl_set = SCU_SGL_ELEMENT_PAIR_B;
305 current_sgl = &pio_sgl->sgl_pair->B;
306 }
307 } else {
308 if (pio_sgl->sgl_pair->next_pair_lower == 0 &&
309 pio_sgl->sgl_pair->next_pair_upper == 0) {
310 current_sgl = NULL;
311 } else {
312 u64 phys_addr;
313
314 phys_addr = pio_sgl->sgl_pair->next_pair_upper;
315 phys_addr <<= 32;
316 phys_addr |= pio_sgl->sgl_pair->next_pair_lower;
317
318 pio_sgl->sgl_pair = scic_request_get_virt_addr(sci_req, phys_addr);
319 pio_sgl->sgl_set = SCU_SGL_ELEMENT_PAIR_A;
320 current_sgl = &pio_sgl->sgl_pair->A;
321 }
322 }
323
324 return current_sgl;
325 }
326
327 /**
328 *
329 * @sci_req:
330 * @completion_code:
331 *
332 * This method processes a TC completion. The expected TC completion is for
333 * the transmission of the H2D register FIS containing the SATA/STP non-data
334 * request. This method always successfully processes the TC completion.
335 * SCI_SUCCESS This value is always returned.
336 */
337 static enum sci_status scic_sds_stp_request_non_data_await_h2d_tc_completion_handler(
338 struct scic_sds_request *sci_req,
339 u32 completion_code)
340 {
341 switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
342 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
343 scic_sds_request_set_status(
344 sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
345 );
346
347 sci_base_state_machine_change_state(
348 &sci_req->started_substate_machine,
349 SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_D2H_SUBSTATE
350 );
351 break;
352
353 default:
354 /*
355 * All other completion status cause the IO to be complete. If a NAK
356 * was received, then it is up to the user to retry the request. */
357 scic_sds_request_set_status(
358 sci_req,
359 SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
360 SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
361 );
362
363 sci_base_state_machine_change_state(
364 &sci_req->state_machine, SCI_BASE_REQUEST_STATE_COMPLETED);
365 break;
366 }
367
368 return SCI_SUCCESS;
369 }
370
371 /**
372 *
373 * @request: This parameter specifies the request for which a frame has been
374 * received.
375 * @frame_index: This parameter specifies the index of the frame that has been
376 * received.
377 *
378 * This method processes frames received from the target while waiting for a
379 * device to host register FIS. If a non-register FIS is received during this
380 * time, it is treated as a protocol violation from an IO perspective. Indicate
381 * if the received frame was processed successfully.
382 */
383 static enum sci_status scic_sds_stp_request_non_data_await_d2h_frame_handler(
384 struct scic_sds_request *sci_req,
385 u32 frame_index)
386 {
387 enum sci_status status;
388 struct dev_to_host_fis *frame_header;
389 u32 *frame_buffer;
390 struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
391 struct scic_sds_controller *scic = sci_req->owning_controller;
392
393 status = scic_sds_unsolicited_frame_control_get_header(&scic->uf_control,
394 frame_index,
395 (void **)&frame_header);
396
397 if (status != SCI_SUCCESS) {
398 dev_err(scic_to_dev(sci_req->owning_controller),
399 "%s: SCIC IO Request 0x%p could not get frame header "
400 "for frame index %d, status %x\n",
401 __func__, stp_req, frame_index, status);
402
403 return status;
404 }
405
406 switch (frame_header->fis_type) {
407 case FIS_REGD2H:
408 scic_sds_unsolicited_frame_control_get_buffer(&scic->uf_control,
409 frame_index,
410 (void **)&frame_buffer);
411
412 scic_sds_controller_copy_sata_response(&sci_req->stp.rsp,
413 frame_header,
414 frame_buffer);
415
416 /* The command has completed with error */
417 scic_sds_request_set_status(sci_req, SCU_TASK_DONE_CHECK_RESPONSE,
418 SCI_FAILURE_IO_RESPONSE_VALID);
419 break;
420
421 default:
422 dev_warn(scic_to_dev(scic),
423 "%s: IO Request:0x%p Frame Id:%d protocol "
424 "violation occurred\n", __func__, stp_req,
425 frame_index);
426
427 scic_sds_request_set_status(sci_req, SCU_TASK_DONE_UNEXP_FIS,
428 SCI_FAILURE_PROTOCOL_VIOLATION);
429 break;
430 }
431
432 sci_base_state_machine_change_state(&sci_req->state_machine,
433 SCI_BASE_REQUEST_STATE_COMPLETED);
434
435 /* Frame has been decoded return it to the controller */
436 scic_sds_controller_release_frame(scic, frame_index);
437
438 return status;
439 }
440
441 /* --------------------------------------------------------------------------- */
442
443 static const struct scic_sds_io_request_state_handler scic_sds_stp_request_started_non_data_substate_handler_table[] = {
444 [SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_H2D_COMPLETION_SUBSTATE] = {
445 .abort_handler = scic_sds_request_started_state_abort_handler,
446 .tc_completion_handler = scic_sds_stp_request_non_data_await_h2d_tc_completion_handler,
447 },
448 [SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_D2H_SUBSTATE] = {
449 .abort_handler = scic_sds_request_started_state_abort_handler,
450 .frame_handler = scic_sds_stp_request_non_data_await_d2h_frame_handler,
451 }
452 };
453
454 static void scic_sds_stp_request_started_non_data_await_h2d_completion_enter(
455 void *object)
456 {
457 struct scic_sds_request *sci_req = object;
458
459 SET_STATE_HANDLER(
460 sci_req,
461 scic_sds_stp_request_started_non_data_substate_handler_table,
462 SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_H2D_COMPLETION_SUBSTATE
463 );
464
465 scic_sds_remote_device_set_working_request(
466 sci_req->target_device, sci_req
467 );
468 }
469
470 static void scic_sds_stp_request_started_non_data_await_d2h_enter(void *object)
471 {
472 struct scic_sds_request *sci_req = object;
473
474 SET_STATE_HANDLER(
475 sci_req,
476 scic_sds_stp_request_started_non_data_substate_handler_table,
477 SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_D2H_SUBSTATE
478 );
479 }
480
481 /* --------------------------------------------------------------------------- */
482
483 static const struct sci_base_state scic_sds_stp_request_started_non_data_substate_table[] = {
484 [SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_H2D_COMPLETION_SUBSTATE] = {
485 .enter_state = scic_sds_stp_request_started_non_data_await_h2d_completion_enter,
486 },
487 [SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_D2H_SUBSTATE] = {
488 .enter_state = scic_sds_stp_request_started_non_data_await_d2h_enter,
489 },
490 };
491
492 enum sci_status scic_sds_stp_non_data_request_construct(struct scic_sds_request *sci_req)
493 {
494 struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
495
496 scic_sds_stp_non_ncq_request_construct(sci_req);
497
498 /* Build the STP task context structure */
499 scu_stp_raw_request_construct_task_context(stp_req, sci_req->task_context_buffer);
500
501 sci_base_state_machine_construct(&sci_req->started_substate_machine,
502 sci_req,
503 scic_sds_stp_request_started_non_data_substate_table,
504 SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_H2D_COMPLETION_SUBSTATE);
505
506 return SCI_SUCCESS;
507 }
508
509 #define SCU_MAX_FRAME_BUFFER_SIZE 0x400 /* 1K is the maximum SCU frame data payload */
510
511 /* transmit DATA_FIS from (current sgl + offset) for input
512 * parameter length. current sgl and offset is alreay stored in the IO request
513 */
514 static enum sci_status scic_sds_stp_request_pio_data_out_trasmit_data_frame(
515 struct scic_sds_request *sci_req,
516 u32 length)
517 {
518 struct scic_sds_controller *scic = sci_req->owning_controller;
519 struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
520 struct scu_task_context *task_context;
521 struct scu_sgl_element *current_sgl;
522
523 /* Recycle the TC and reconstruct it for sending out DATA FIS containing
524 * for the data from current_sgl+offset for the input length
525 */
526 task_context = scic_sds_controller_get_task_context_buffer(scic,
527 sci_req->io_tag);
528
529 if (stp_req->type.pio.request_current.sgl_set == SCU_SGL_ELEMENT_PAIR_A)
530 current_sgl = &stp_req->type.pio.request_current.sgl_pair->A;
531 else
532 current_sgl = &stp_req->type.pio.request_current.sgl_pair->B;
533
534 /* update the TC */
535 task_context->command_iu_upper = current_sgl->address_upper;
536 task_context->command_iu_lower = current_sgl->address_lower;
537 task_context->transfer_length_bytes = length;
538 task_context->type.stp.fis_type = FIS_DATA;
539
540 /* send the new TC out. */
541 return scic_controller_continue_io(sci_req);
542 }
543
544 static enum sci_status scic_sds_stp_request_pio_data_out_transmit_data(struct scic_sds_request *sci_req)
545 {
546
547 struct scu_sgl_element *current_sgl;
548 u32 sgl_offset;
549 u32 remaining_bytes_in_current_sgl = 0;
550 enum sci_status status = SCI_SUCCESS;
551 struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
552
553 sgl_offset = stp_req->type.pio.request_current.sgl_offset;
554
555 if (stp_req->type.pio.request_current.sgl_set == SCU_SGL_ELEMENT_PAIR_A) {
556 current_sgl = &(stp_req->type.pio.request_current.sgl_pair->A);
557 remaining_bytes_in_current_sgl = stp_req->type.pio.request_current.sgl_pair->A.length - sgl_offset;
558 } else {
559 current_sgl = &(stp_req->type.pio.request_current.sgl_pair->B);
560 remaining_bytes_in_current_sgl = stp_req->type.pio.request_current.sgl_pair->B.length - sgl_offset;
561 }
562
563
564 if (stp_req->type.pio.pio_transfer_bytes > 0) {
565 if (stp_req->type.pio.pio_transfer_bytes >= remaining_bytes_in_current_sgl) {
566 /* recycle the TC and send the H2D Data FIS from (current sgl + sgl_offset) and length = remaining_bytes_in_current_sgl */
567 status = scic_sds_stp_request_pio_data_out_trasmit_data_frame(sci_req, remaining_bytes_in_current_sgl);
568 if (status == SCI_SUCCESS) {
569 stp_req->type.pio.pio_transfer_bytes -= remaining_bytes_in_current_sgl;
570
571 /* update the current sgl, sgl_offset and save for future */
572 current_sgl = scic_sds_stp_request_pio_get_next_sgl(stp_req);
573 sgl_offset = 0;
574 }
575 } else if (stp_req->type.pio.pio_transfer_bytes < remaining_bytes_in_current_sgl) {
576 /* recycle the TC and send the H2D Data FIS from (current sgl + sgl_offset) and length = type.pio.pio_transfer_bytes */
577 scic_sds_stp_request_pio_data_out_trasmit_data_frame(sci_req, stp_req->type.pio.pio_transfer_bytes);
578
579 if (status == SCI_SUCCESS) {
580 /* Sgl offset will be adjusted and saved for future */
581 sgl_offset += stp_req->type.pio.pio_transfer_bytes;
582 current_sgl->address_lower += stp_req->type.pio.pio_transfer_bytes;
583 stp_req->type.pio.pio_transfer_bytes = 0;
584 }
585 }
586 }
587
588 if (status == SCI_SUCCESS) {
589 stp_req->type.pio.request_current.sgl_offset = sgl_offset;
590 }
591
592 return status;
593 }
594
595 /**
596 *
597 * @stp_request: The request that is used for the SGL processing.
598 * @data_buffer: The buffer of data to be copied.
599 * @length: The length of the data transfer.
600 *
601 * Copy the data from the buffer for the length specified to the IO reqeust SGL
602 * specified data region. enum sci_status
603 */
604 static enum sci_status
605 scic_sds_stp_request_pio_data_in_copy_data_buffer(struct scic_sds_stp_request *stp_req,
606 u8 *data_buf, u32 len)
607 {
608 struct scic_sds_request *sci_req;
609 struct isci_request *ireq;
610 u8 *src_addr;
611 int copy_len;
612 struct sas_task *task;
613 struct scatterlist *sg;
614 void *kaddr;
615 int total_len = len;
616
617 sci_req = to_sci_req(stp_req);
618 ireq = sci_req_to_ireq(sci_req);
619 task = isci_request_access_task(ireq);
620 src_addr = data_buf;
621
622 if (task->num_scatter > 0) {
623 sg = task->scatter;
624
625 while (total_len > 0) {
626 struct page *page = sg_page(sg);
627
628 copy_len = min_t(int, total_len, sg_dma_len(sg));
629 kaddr = kmap_atomic(page, KM_IRQ0);
630 memcpy(kaddr + sg->offset, src_addr, copy_len);
631 kunmap_atomic(kaddr, KM_IRQ0);
632 total_len -= copy_len;
633 src_addr += copy_len;
634 sg = sg_next(sg);
635 }
636 } else {
637 BUG_ON(task->total_xfer_len < total_len);
638 memcpy(task->scatter, src_addr, total_len);
639 }
640
641 return SCI_SUCCESS;
642 }
643
644 /**
645 *
646 * @sci_req: The PIO DATA IN request that is to receive the data.
647 * @data_buffer: The buffer to copy from.
648 *
649 * Copy the data buffer to the io request data region. enum sci_status
650 */
651 static enum sci_status scic_sds_stp_request_pio_data_in_copy_data(
652 struct scic_sds_stp_request *sci_req,
653 u8 *data_buffer)
654 {
655 enum sci_status status;
656
657 /*
658 * If there is less than 1K remaining in the transfer request
659 * copy just the data for the transfer */
660 if (sci_req->type.pio.pio_transfer_bytes < SCU_MAX_FRAME_BUFFER_SIZE) {
661 status = scic_sds_stp_request_pio_data_in_copy_data_buffer(
662 sci_req, data_buffer, sci_req->type.pio.pio_transfer_bytes);
663
664 if (status == SCI_SUCCESS)
665 sci_req->type.pio.pio_transfer_bytes = 0;
666 } else {
667 /* We are transfering the whole frame so copy */
668 status = scic_sds_stp_request_pio_data_in_copy_data_buffer(
669 sci_req, data_buffer, SCU_MAX_FRAME_BUFFER_SIZE);
670
671 if (status == SCI_SUCCESS)
672 sci_req->type.pio.pio_transfer_bytes -= SCU_MAX_FRAME_BUFFER_SIZE;
673 }
674
675 return status;
676 }
677
678 /**
679 *
680 * @sci_req:
681 * @completion_code:
682 *
683 * enum sci_status
684 */
685 static enum sci_status scic_sds_stp_request_pio_await_h2d_completion_tc_completion_handler(
686 struct scic_sds_request *sci_req,
687 u32 completion_code)
688 {
689 enum sci_status status = SCI_SUCCESS;
690
691 switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
692 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
693 scic_sds_request_set_status(
694 sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
695 );
696
697 sci_base_state_machine_change_state(
698 &sci_req->started_substate_machine,
699 SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE
700 );
701 break;
702
703 default:
704 /*
705 * All other completion status cause the IO to be complete. If a NAK
706 * was received, then it is up to the user to retry the request. */
707 scic_sds_request_set_status(
708 sci_req,
709 SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
710 SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
711 );
712
713 sci_base_state_machine_change_state(
714 &sci_req->state_machine,
715 SCI_BASE_REQUEST_STATE_COMPLETED
716 );
717 break;
718 }
719
720 return status;
721 }
722
723 static enum sci_status scic_sds_stp_request_pio_await_frame_frame_handler(struct scic_sds_request *sci_req,
724 u32 frame_index)
725 {
726 struct scic_sds_controller *scic = sci_req->owning_controller;
727 struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
728 struct isci_request *ireq = sci_req_to_ireq(sci_req);
729 struct sas_task *task = isci_request_access_task(ireq);
730 struct dev_to_host_fis *frame_header;
731 enum sci_status status;
732 u32 *frame_buffer;
733
734 status = scic_sds_unsolicited_frame_control_get_header(&scic->uf_control,
735 frame_index,
736 (void **)&frame_header);
737
738 if (status != SCI_SUCCESS) {
739 dev_err(scic_to_dev(scic),
740 "%s: SCIC IO Request 0x%p could not get frame header "
741 "for frame index %d, status %x\n",
742 __func__, stp_req, frame_index, status);
743 return status;
744 }
745
746 switch (frame_header->fis_type) {
747 case FIS_PIO_SETUP:
748 /* Get from the frame buffer the PIO Setup Data */
749 scic_sds_unsolicited_frame_control_get_buffer(&scic->uf_control,
750 frame_index,
751 (void **)&frame_buffer);
752
753 /* Get the data from the PIO Setup The SCU Hardware returns
754 * first word in the frame_header and the rest of the data is in
755 * the frame buffer so we need to back up one dword
756 */
757
758 /* transfer_count: first 16bits in the 4th dword */
759 stp_req->type.pio.pio_transfer_bytes = frame_buffer[3] & 0xffff;
760
761 /* ending_status: 4th byte in the 3rd dword */
762 stp_req->type.pio.ending_status = (frame_buffer[2] >> 24) & 0xff;
763
764 scic_sds_controller_copy_sata_response(&sci_req->stp.rsp,
765 frame_header,
766 frame_buffer);
767
768 sci_req->stp.rsp.status = stp_req->type.pio.ending_status;
769
770 /* The next state is dependent on whether the
771 * request was PIO Data-in or Data out
772 */
773 if (task->data_dir == DMA_FROM_DEVICE) {
774 sci_base_state_machine_change_state(&sci_req->started_substate_machine,
775 SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_IN_AWAIT_DATA_SUBSTATE);
776 } else if (task->data_dir == DMA_TO_DEVICE) {
777 /* Transmit data */
778 status = scic_sds_stp_request_pio_data_out_transmit_data(sci_req);
779 if (status != SCI_SUCCESS)
780 break;
781 sci_base_state_machine_change_state(&sci_req->started_substate_machine,
782 SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_OUT_TRANSMIT_DATA_SUBSTATE);
783 }
784 break;
785 case FIS_SETDEVBITS:
786 sci_base_state_machine_change_state(&sci_req->started_substate_machine,
787 SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE);
788 break;
789 case FIS_REGD2H:
790 if (frame_header->status & ATA_BUSY) {
791 /* Now why is the drive sending a D2H Register FIS when
792 * it is still busy? Do nothing since we are still in
793 * the right state.
794 */
795 dev_dbg(scic_to_dev(scic),
796 "%s: SCIC PIO Request 0x%p received "
797 "D2H Register FIS with BSY status "
798 "0x%x\n", __func__, stp_req,
799 frame_header->status);
800 break;
801 }
802
803 scic_sds_unsolicited_frame_control_get_buffer(&scic->uf_control,
804 frame_index,
805 (void **)&frame_buffer);
806
807 scic_sds_controller_copy_sata_response(&sci_req->stp.req,
808 frame_header,
809 frame_buffer);
810
811 scic_sds_request_set_status(sci_req,
812 SCU_TASK_DONE_CHECK_RESPONSE,
813 SCI_FAILURE_IO_RESPONSE_VALID);
814
815 sci_base_state_machine_change_state(&sci_req->state_machine,
816 SCI_BASE_REQUEST_STATE_COMPLETED);
817 break;
818 default:
819 /* FIXME: what do we do here? */
820 break;
821 }
822
823 /* Frame is decoded return it to the controller */
824 scic_sds_controller_release_frame(scic, frame_index);
825
826 return status;
827 }
828
829 static enum sci_status scic_sds_stp_request_pio_data_in_await_data_frame_handler(struct scic_sds_request *sci_req,
830 u32 frame_index)
831 {
832 enum sci_status status;
833 struct dev_to_host_fis *frame_header;
834 struct sata_fis_data *frame_buffer;
835 struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
836 struct scic_sds_controller *scic = sci_req->owning_controller;
837
838 status = scic_sds_unsolicited_frame_control_get_header(&scic->uf_control,
839 frame_index,
840 (void **)&frame_header);
841
842 if (status != SCI_SUCCESS) {
843 dev_err(scic_to_dev(scic),
844 "%s: SCIC IO Request 0x%p could not get frame header "
845 "for frame index %d, status %x\n",
846 __func__, stp_req, frame_index, status);
847 return status;
848 }
849
850 if (frame_header->fis_type == FIS_DATA) {
851 if (stp_req->type.pio.request_current.sgl_pair == NULL) {
852 sci_req->saved_rx_frame_index = frame_index;
853 stp_req->type.pio.pio_transfer_bytes = 0;
854 } else {
855 scic_sds_unsolicited_frame_control_get_buffer(&scic->uf_control,
856 frame_index,
857 (void **)&frame_buffer);
858
859 status = scic_sds_stp_request_pio_data_in_copy_data(stp_req,
860 (u8 *)frame_buffer);
861
862 /* Frame is decoded return it to the controller */
863 scic_sds_controller_release_frame(scic, frame_index);
864 }
865
866 /* Check for the end of the transfer, are there more
867 * bytes remaining for this data transfer
868 */
869 if (status != SCI_SUCCESS ||
870 stp_req->type.pio.pio_transfer_bytes != 0)
871 return status;
872
873 if ((stp_req->type.pio.ending_status & ATA_BUSY) == 0) {
874 scic_sds_request_set_status(sci_req,
875 SCU_TASK_DONE_CHECK_RESPONSE,
876 SCI_FAILURE_IO_RESPONSE_VALID);
877
878 sci_base_state_machine_change_state(&sci_req->state_machine,
879 SCI_BASE_REQUEST_STATE_COMPLETED);
880 } else {
881 sci_base_state_machine_change_state(&sci_req->started_substate_machine,
882 SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE);
883 }
884 } else {
885 dev_err(scic_to_dev(scic),
886 "%s: SCIC PIO Request 0x%p received frame %d "
887 "with fis type 0x%02x when expecting a data "
888 "fis.\n", __func__, stp_req, frame_index,
889 frame_header->fis_type);
890
891 scic_sds_request_set_status(sci_req,
892 SCU_TASK_DONE_GOOD,
893 SCI_FAILURE_IO_REQUIRES_SCSI_ABORT);
894
895 sci_base_state_machine_change_state(&sci_req->state_machine,
896 SCI_BASE_REQUEST_STATE_COMPLETED);
897
898 /* Frame is decoded return it to the controller */
899 scic_sds_controller_release_frame(scic, frame_index);
900 }
901
902 return status;
903 }
904
905
906 /**
907 *
908 * @sci_req:
909 * @completion_code:
910 *
911 * enum sci_status
912 */
913 static enum sci_status scic_sds_stp_request_pio_data_out_await_data_transmit_completion_tc_completion_handler(
914
915 struct scic_sds_request *sci_req,
916 u32 completion_code)
917 {
918 enum sci_status status = SCI_SUCCESS;
919 bool all_frames_transferred = false;
920 struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
921
922 switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
923 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
924 /* Transmit data */
925 if (stp_req->type.pio.pio_transfer_bytes != 0) {
926 status = scic_sds_stp_request_pio_data_out_transmit_data(sci_req);
927 if (status == SCI_SUCCESS) {
928 if (stp_req->type.pio.pio_transfer_bytes == 0)
929 all_frames_transferred = true;
930 }
931 } else if (stp_req->type.pio.pio_transfer_bytes == 0) {
932 /*
933 * this will happen if the all data is written at the
934 * first time after the pio setup fis is received
935 */
936 all_frames_transferred = true;
937 }
938
939 /* all data transferred. */
940 if (all_frames_transferred) {
941 /*
942 * Change the state to SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_IN_AWAIT_FRAME_SUBSTATE
943 * and wait for PIO_SETUP fis / or D2H REg fis. */
944 sci_base_state_machine_change_state(
945 &sci_req->started_substate_machine,
946 SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE
947 );
948 }
949 break;
950
951 default:
952 /*
953 * All other completion status cause the IO to be complete. If a NAK
954 * was received, then it is up to the user to retry the request. */
955 scic_sds_request_set_status(
956 sci_req,
957 SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
958 SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
959 );
960
961 sci_base_state_machine_change_state(
962 &sci_req->state_machine,
963 SCI_BASE_REQUEST_STATE_COMPLETED
964 );
965 break;
966 }
967
968 return status;
969 }
970
971 /**
972 *
973 * @request: This is the request which is receiving the event.
974 * @event_code: This is the event code that the request on which the request is
975 * expected to take action.
976 *
977 * This method will handle any link layer events while waiting for the data
978 * frame. enum sci_status SCI_SUCCESS SCI_FAILURE
979 */
980 static enum sci_status scic_sds_stp_request_pio_data_in_await_data_event_handler(
981 struct scic_sds_request *request,
982 u32 event_code)
983 {
984 enum sci_status status;
985
986 switch (scu_get_event_specifier(event_code)) {
987 case SCU_TASK_DONE_CRC_ERR << SCU_EVENT_SPECIFIC_CODE_SHIFT:
988 /*
989 * We are waiting for data and the SCU has R_ERR the data frame.
990 * Go back to waiting for the D2H Register FIS */
991 sci_base_state_machine_change_state(
992 &request->started_substate_machine,
993 SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE
994 );
995
996 status = SCI_SUCCESS;
997 break;
998
999 default:
1000 dev_err(scic_to_dev(request->owning_controller),
1001 "%s: SCIC PIO Request 0x%p received unexpected "
1002 "event 0x%08x\n",
1003 __func__, request, event_code);
1004
1005 /* / @todo Should we fail the PIO request when we get an unexpected event? */
1006 status = SCI_FAILURE;
1007 break;
1008 }
1009
1010 return status;
1011 }
1012
1013 /* --------------------------------------------------------------------------- */
1014
1015 static const struct scic_sds_io_request_state_handler scic_sds_stp_request_started_pio_substate_handler_table[] = {
1016 [SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_H2D_COMPLETION_SUBSTATE] = {
1017 .abort_handler = scic_sds_request_started_state_abort_handler,
1018 .tc_completion_handler = scic_sds_stp_request_pio_await_h2d_completion_tc_completion_handler,
1019 },
1020 [SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE] = {
1021 .abort_handler = scic_sds_request_started_state_abort_handler,
1022 .frame_handler = scic_sds_stp_request_pio_await_frame_frame_handler
1023 },
1024 [SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_IN_AWAIT_DATA_SUBSTATE] = {
1025 .abort_handler = scic_sds_request_started_state_abort_handler,
1026 .event_handler = scic_sds_stp_request_pio_data_in_await_data_event_handler,
1027 .frame_handler = scic_sds_stp_request_pio_data_in_await_data_frame_handler
1028 },
1029 [SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_OUT_TRANSMIT_DATA_SUBSTATE] = {
1030 .abort_handler = scic_sds_request_started_state_abort_handler,
1031 .tc_completion_handler = scic_sds_stp_request_pio_data_out_await_data_transmit_completion_tc_completion_handler,
1032 }
1033 };
1034
1035 static void scic_sds_stp_request_started_pio_await_h2d_completion_enter(
1036 void *object)
1037 {
1038 struct scic_sds_request *sci_req = object;
1039
1040 SET_STATE_HANDLER(
1041 sci_req,
1042 scic_sds_stp_request_started_pio_substate_handler_table,
1043 SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_H2D_COMPLETION_SUBSTATE
1044 );
1045
1046 scic_sds_remote_device_set_working_request(
1047 sci_req->target_device, sci_req);
1048 }
1049
1050 static void scic_sds_stp_request_started_pio_await_frame_enter(void *object)
1051 {
1052 struct scic_sds_request *sci_req = object;
1053
1054 SET_STATE_HANDLER(
1055 sci_req,
1056 scic_sds_stp_request_started_pio_substate_handler_table,
1057 SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE
1058 );
1059 }
1060
1061 static void scic_sds_stp_request_started_pio_data_in_await_data_enter(
1062 void *object)
1063 {
1064 struct scic_sds_request *sci_req = object;
1065
1066 SET_STATE_HANDLER(
1067 sci_req,
1068 scic_sds_stp_request_started_pio_substate_handler_table,
1069 SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_IN_AWAIT_DATA_SUBSTATE
1070 );
1071 }
1072
1073 static void scic_sds_stp_request_started_pio_data_out_transmit_data_enter(
1074 void *object)
1075 {
1076 struct scic_sds_request *sci_req = object;
1077
1078 SET_STATE_HANDLER(
1079 sci_req,
1080 scic_sds_stp_request_started_pio_substate_handler_table,
1081 SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_OUT_TRANSMIT_DATA_SUBSTATE
1082 );
1083 }
1084
1085 /* --------------------------------------------------------------------------- */
1086
1087 static const struct sci_base_state scic_sds_stp_request_started_pio_substate_table[] = {
1088 [SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_H2D_COMPLETION_SUBSTATE] = {
1089 .enter_state = scic_sds_stp_request_started_pio_await_h2d_completion_enter,
1090 },
1091 [SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE] = {
1092 .enter_state = scic_sds_stp_request_started_pio_await_frame_enter,
1093 },
1094 [SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_IN_AWAIT_DATA_SUBSTATE] = {
1095 .enter_state = scic_sds_stp_request_started_pio_data_in_await_data_enter,
1096 },
1097 [SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_OUT_TRANSMIT_DATA_SUBSTATE] = {
1098 .enter_state = scic_sds_stp_request_started_pio_data_out_transmit_data_enter,
1099 }
1100 };
1101
1102 enum sci_status
1103 scic_sds_stp_pio_request_construct(struct scic_sds_request *sci_req,
1104 bool copy_rx_frame)
1105 {
1106 struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
1107 struct scic_sds_stp_pio_request *pio = &stp_req->type.pio;
1108
1109 scic_sds_stp_non_ncq_request_construct(sci_req);
1110
1111 scu_stp_raw_request_construct_task_context(stp_req,
1112 sci_req->task_context_buffer);
1113
1114 pio->current_transfer_bytes = 0;
1115 pio->ending_error = 0;
1116 pio->ending_status = 0;
1117
1118 pio->request_current.sgl_offset = 0;
1119 pio->request_current.sgl_set = SCU_SGL_ELEMENT_PAIR_A;
1120
1121 if (copy_rx_frame) {
1122 scic_sds_request_build_sgl(sci_req);
1123 /* Since the IO request copy of the TC contains the same data as
1124 * the actual TC this pointer is vaild for either.
1125 */
1126 pio->request_current.sgl_pair = &sci_req->task_context_buffer->sgl_pair_ab;
1127 } else {
1128 /* The user does not want the data copied to the SGL buffer location */
1129 pio->request_current.sgl_pair = NULL;
1130 }
1131
1132 sci_base_state_machine_construct(&sci_req->started_substate_machine,
1133 sci_req,
1134 scic_sds_stp_request_started_pio_substate_table,
1135 SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_H2D_COMPLETION_SUBSTATE);
1136
1137 return SCI_SUCCESS;
1138 }
1139
1140 static void scic_sds_stp_request_udma_complete_request(
1141 struct scic_sds_request *request,
1142 u32 scu_status,
1143 enum sci_status sci_status)
1144 {
1145 scic_sds_request_set_status(request, scu_status, sci_status);
1146 sci_base_state_machine_change_state(&request->state_machine,
1147 SCI_BASE_REQUEST_STATE_COMPLETED);
1148 }
1149
1150 static enum sci_status scic_sds_stp_request_udma_general_frame_handler(struct scic_sds_request *sci_req,
1151 u32 frame_index)
1152 {
1153 struct scic_sds_controller *scic = sci_req->owning_controller;
1154 struct dev_to_host_fis *frame_header;
1155 enum sci_status status;
1156 u32 *frame_buffer;
1157
1158 status = scic_sds_unsolicited_frame_control_get_header(&scic->uf_control,
1159 frame_index,
1160 (void **)&frame_header);
1161
1162 if ((status == SCI_SUCCESS) &&
1163 (frame_header->fis_type == FIS_REGD2H)) {
1164 scic_sds_unsolicited_frame_control_get_buffer(&scic->uf_control,
1165 frame_index,
1166 (void **)&frame_buffer);
1167
1168 scic_sds_controller_copy_sata_response(&sci_req->stp.rsp,
1169 frame_header,
1170 frame_buffer);
1171 }
1172
1173 scic_sds_controller_release_frame(scic, frame_index);
1174
1175 return status;
1176 }
1177
1178 static enum sci_status scic_sds_stp_request_udma_await_tc_completion_tc_completion_handler(
1179 struct scic_sds_request *sci_req,
1180 u32 completion_code)
1181 {
1182 enum sci_status status = SCI_SUCCESS;
1183
1184 switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
1185 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
1186 scic_sds_stp_request_udma_complete_request(sci_req,
1187 SCU_TASK_DONE_GOOD,
1188 SCI_SUCCESS);
1189 break;
1190 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_UNEXP_FIS):
1191 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_REG_ERR):
1192 /*
1193 * We must check ther response buffer to see if the D2H Register FIS was
1194 * received before we got the TC completion. */
1195 if (sci_req->stp.rsp.fis_type == FIS_REGD2H) {
1196 scic_sds_remote_device_suspend(sci_req->target_device,
1197 SCU_EVENT_SPECIFIC(SCU_NORMALIZE_COMPLETION_STATUS(completion_code)));
1198
1199 scic_sds_stp_request_udma_complete_request(sci_req,
1200 SCU_TASK_DONE_CHECK_RESPONSE,
1201 SCI_FAILURE_IO_RESPONSE_VALID);
1202 } else {
1203 /*
1204 * If we have an error completion status for the TC then we can expect a
1205 * D2H register FIS from the device so we must change state to wait for it */
1206 sci_base_state_machine_change_state(&sci_req->started_substate_machine,
1207 SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_D2H_REG_FIS_SUBSTATE);
1208 }
1209 break;
1210
1211 /*
1212 * / @todo Check to see if any of these completion status need to wait for
1213 * / the device to host register fis. */
1214 /* / @todo We can retry the command for SCU_TASK_DONE_CMD_LL_R_ERR - this comes only for B0 */
1215 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_INV_FIS_LEN):
1216 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_MAX_PLD_ERR):
1217 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_LL_R_ERR):
1218 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_CMD_LL_R_ERR):
1219 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_CRC_ERR):
1220 scic_sds_remote_device_suspend(sci_req->target_device,
1221 SCU_EVENT_SPECIFIC(SCU_NORMALIZE_COMPLETION_STATUS(completion_code)));
1222 /* Fall through to the default case */
1223 default:
1224 /* All other completion status cause the IO to be complete. */
1225 scic_sds_stp_request_udma_complete_request(sci_req,
1226 SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
1227 SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR);
1228 break;
1229 }
1230
1231 return status;
1232 }
1233
1234 static enum sci_status scic_sds_stp_request_udma_await_d2h_reg_fis_frame_handler(
1235 struct scic_sds_request *sci_req,
1236 u32 frame_index)
1237 {
1238 enum sci_status status;
1239
1240 /* Use the general frame handler to copy the resposne data */
1241 status = scic_sds_stp_request_udma_general_frame_handler(sci_req, frame_index);
1242
1243 if (status != SCI_SUCCESS)
1244 return status;
1245
1246 scic_sds_stp_request_udma_complete_request(sci_req,
1247 SCU_TASK_DONE_CHECK_RESPONSE,
1248 SCI_FAILURE_IO_RESPONSE_VALID);
1249
1250 return status;
1251 }
1252
1253 /* --------------------------------------------------------------------------- */
1254
1255 static const struct scic_sds_io_request_state_handler scic_sds_stp_request_started_udma_substate_handler_table[] = {
1256 [SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_TC_COMPLETION_SUBSTATE] = {
1257 .abort_handler = scic_sds_request_started_state_abort_handler,
1258 .tc_completion_handler = scic_sds_stp_request_udma_await_tc_completion_tc_completion_handler,
1259 .frame_handler = scic_sds_stp_request_udma_general_frame_handler,
1260 },
1261 [SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_D2H_REG_FIS_SUBSTATE] = {
1262 .abort_handler = scic_sds_request_started_state_abort_handler,
1263 .frame_handler = scic_sds_stp_request_udma_await_d2h_reg_fis_frame_handler,
1264 },
1265 };
1266
1267 static void scic_sds_stp_request_started_udma_await_tc_completion_enter(
1268 void *object)
1269 {
1270 struct scic_sds_request *sci_req = object;
1271
1272 SET_STATE_HANDLER(
1273 sci_req,
1274 scic_sds_stp_request_started_udma_substate_handler_table,
1275 SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_TC_COMPLETION_SUBSTATE
1276 );
1277 }
1278
1279 /**
1280 *
1281 *
1282 * This state is entered when there is an TC completion failure. The hardware
1283 * received an unexpected condition while processing the IO request and now
1284 * will UF the D2H register FIS to complete the IO.
1285 */
1286 static void scic_sds_stp_request_started_udma_await_d2h_reg_fis_enter(
1287 void *object)
1288 {
1289 struct scic_sds_request *sci_req = object;
1290
1291 SET_STATE_HANDLER(
1292 sci_req,
1293 scic_sds_stp_request_started_udma_substate_handler_table,
1294 SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_D2H_REG_FIS_SUBSTATE
1295 );
1296 }
1297
1298 /* --------------------------------------------------------------------------- */
1299
1300 static const struct sci_base_state scic_sds_stp_request_started_udma_substate_table[] = {
1301 [SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_TC_COMPLETION_SUBSTATE] = {
1302 .enter_state = scic_sds_stp_request_started_udma_await_tc_completion_enter,
1303 },
1304 [SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_D2H_REG_FIS_SUBSTATE] = {
1305 .enter_state = scic_sds_stp_request_started_udma_await_d2h_reg_fis_enter,
1306 },
1307 };
1308
1309 enum sci_status scic_sds_stp_udma_request_construct(struct scic_sds_request *sci_req,
1310 u32 len,
1311 enum dma_data_direction dir)
1312 {
1313 scic_sds_stp_non_ncq_request_construct(sci_req);
1314
1315 scic_sds_stp_optimized_request_construct(sci_req, SCU_TASK_TYPE_DMA_IN,
1316 len, dir);
1317
1318 sci_base_state_machine_construct(
1319 &sci_req->started_substate_machine,
1320 sci_req,
1321 scic_sds_stp_request_started_udma_substate_table,
1322 SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_TC_COMPLETION_SUBSTATE
1323 );
1324
1325 return SCI_SUCCESS;
1326 }
1327
1328 /**
1329 *
1330 * @sci_req:
1331 * @completion_code:
1332 *
1333 * This method processes a TC completion. The expected TC completion is for
1334 * the transmission of the H2D register FIS containing the SATA/STP non-data
1335 * request. This method always successfully processes the TC completion.
1336 * SCI_SUCCESS This value is always returned.
1337 */
1338 static enum sci_status scic_sds_stp_request_soft_reset_await_h2d_asserted_tc_completion_handler(
1339 struct scic_sds_request *sci_req,
1340 u32 completion_code)
1341 {
1342 switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
1343 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
1344 scic_sds_request_set_status(
1345 sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
1346 );
1347
1348 sci_base_state_machine_change_state(
1349 &sci_req->started_substate_machine,
1350 SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_DIAGNOSTIC_COMPLETION_SUBSTATE
1351 );
1352 break;
1353
1354 default:
1355 /*
1356 * All other completion status cause the IO to be complete. If a NAK
1357 * was received, then it is up to the user to retry the request. */
1358 scic_sds_request_set_status(
1359 sci_req,
1360 SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
1361 SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
1362 );
1363
1364 sci_base_state_machine_change_state(
1365 &sci_req->state_machine, SCI_BASE_REQUEST_STATE_COMPLETED);
1366 break;
1367 }
1368
1369 return SCI_SUCCESS;
1370 }
1371
1372 /**
1373 *
1374 * @sci_req:
1375 * @completion_code:
1376 *
1377 * This method processes a TC completion. The expected TC completion is for
1378 * the transmission of the H2D register FIS containing the SATA/STP non-data
1379 * request. This method always successfully processes the TC completion.
1380 * SCI_SUCCESS This value is always returned.
1381 */
1382 static enum sci_status scic_sds_stp_request_soft_reset_await_h2d_diagnostic_tc_completion_handler(
1383 struct scic_sds_request *sci_req,
1384 u32 completion_code)
1385 {
1386 switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
1387 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
1388 scic_sds_request_set_status(
1389 sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
1390 );
1391
1392 sci_base_state_machine_change_state(
1393 &sci_req->started_substate_machine,
1394 SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_D2H_RESPONSE_FRAME_SUBSTATE
1395 );
1396 break;
1397
1398 default:
1399 /*
1400 * All other completion status cause the IO to be complete. If a NAK
1401 * was received, then it is up to the user to retry the request. */
1402 scic_sds_request_set_status(
1403 sci_req,
1404 SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
1405 SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
1406 );
1407
1408 sci_base_state_machine_change_state(&sci_req->state_machine,
1409 SCI_BASE_REQUEST_STATE_COMPLETED);
1410 break;
1411 }
1412
1413 return SCI_SUCCESS;
1414 }
1415
1416 /**
1417 *
1418 * @request: This parameter specifies the request for which a frame has been
1419 * received.
1420 * @frame_index: This parameter specifies the index of the frame that has been
1421 * received.
1422 *
1423 * This method processes frames received from the target while waiting for a
1424 * device to host register FIS. If a non-register FIS is received during this
1425 * time, it is treated as a protocol violation from an IO perspective. Indicate
1426 * if the received frame was processed successfully.
1427 */
1428 static enum sci_status scic_sds_stp_request_soft_reset_await_d2h_frame_handler(
1429 struct scic_sds_request *sci_req,
1430 u32 frame_index)
1431 {
1432 enum sci_status status;
1433 struct dev_to_host_fis *frame_header;
1434 u32 *frame_buffer;
1435 struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
1436 struct scic_sds_controller *scic = sci_req->owning_controller;
1437
1438 status = scic_sds_unsolicited_frame_control_get_header(&scic->uf_control,
1439 frame_index,
1440 (void **)&frame_header);
1441 if (status != SCI_SUCCESS) {
1442 dev_err(scic_to_dev(scic),
1443 "%s: SCIC IO Request 0x%p could not get frame header "
1444 "for frame index %d, status %x\n",
1445 __func__, stp_req, frame_index, status);
1446 return status;
1447 }
1448
1449 switch (frame_header->fis_type) {
1450 case FIS_REGD2H:
1451 scic_sds_unsolicited_frame_control_get_buffer(&scic->uf_control,
1452 frame_index,
1453 (void **)&frame_buffer);
1454
1455 scic_sds_controller_copy_sata_response(&sci_req->stp.rsp,
1456 frame_header,
1457 frame_buffer);
1458
1459 /* The command has completed with error */
1460 scic_sds_request_set_status(sci_req,
1461 SCU_TASK_DONE_CHECK_RESPONSE,
1462 SCI_FAILURE_IO_RESPONSE_VALID);
1463 break;
1464
1465 default:
1466 dev_warn(scic_to_dev(scic),
1467 "%s: IO Request:0x%p Frame Id:%d protocol "
1468 "violation occurred\n", __func__, stp_req,
1469 frame_index);
1470
1471 scic_sds_request_set_status(sci_req, SCU_TASK_DONE_UNEXP_FIS,
1472 SCI_FAILURE_PROTOCOL_VIOLATION);
1473 break;
1474 }
1475
1476 sci_base_state_machine_change_state(&sci_req->state_machine,
1477 SCI_BASE_REQUEST_STATE_COMPLETED);
1478
1479 /* Frame has been decoded return it to the controller */
1480 scic_sds_controller_release_frame(scic, frame_index);
1481
1482 return status;
1483 }
1484
1485 /* --------------------------------------------------------------------------- */
1486
1487 static const struct scic_sds_io_request_state_handler scic_sds_stp_request_started_soft_reset_substate_handler_table[] = {
1488 [SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_ASSERTED_COMPLETION_SUBSTATE] = {
1489 .abort_handler = scic_sds_request_started_state_abort_handler,
1490 .tc_completion_handler = scic_sds_stp_request_soft_reset_await_h2d_asserted_tc_completion_handler,
1491 },
1492 [SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_DIAGNOSTIC_COMPLETION_SUBSTATE] = {
1493 .abort_handler = scic_sds_request_started_state_abort_handler,
1494 .tc_completion_handler = scic_sds_stp_request_soft_reset_await_h2d_diagnostic_tc_completion_handler,
1495 },
1496 [SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_D2H_RESPONSE_FRAME_SUBSTATE] = {
1497 .abort_handler = scic_sds_request_started_state_abort_handler,
1498 .frame_handler = scic_sds_stp_request_soft_reset_await_d2h_frame_handler,
1499 },
1500 };
1501
1502 static void scic_sds_stp_request_started_soft_reset_await_h2d_asserted_completion_enter(
1503 void *object)
1504 {
1505 struct scic_sds_request *sci_req = object;
1506
1507 SET_STATE_HANDLER(
1508 sci_req,
1509 scic_sds_stp_request_started_soft_reset_substate_handler_table,
1510 SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_ASSERTED_COMPLETION_SUBSTATE
1511 );
1512
1513 scic_sds_remote_device_set_working_request(
1514 sci_req->target_device, sci_req
1515 );
1516 }
1517
1518 static void scic_sds_stp_request_started_soft_reset_await_h2d_diagnostic_completion_enter(
1519 void *object)
1520 {
1521 struct scic_sds_request *sci_req = object;
1522 struct scu_task_context *task_context;
1523 struct host_to_dev_fis *h2d_fis;
1524 enum sci_status status;
1525
1526 /* Clear the SRST bit */
1527 h2d_fis = &sci_req->stp.cmd;
1528 h2d_fis->control = 0;
1529
1530 /* Clear the TC control bit */
1531 task_context = scic_sds_controller_get_task_context_buffer(
1532 sci_req->owning_controller, sci_req->io_tag);
1533 task_context->control_frame = 0;
1534
1535 status = scic_controller_continue_io(sci_req);
1536 if (status == SCI_SUCCESS) {
1537 SET_STATE_HANDLER(
1538 sci_req,
1539 scic_sds_stp_request_started_soft_reset_substate_handler_table,
1540 SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_DIAGNOSTIC_COMPLETION_SUBSTATE
1541 );
1542 }
1543 }
1544
1545 static void scic_sds_stp_request_started_soft_reset_await_d2h_response_enter(
1546 void *object)
1547 {
1548 struct scic_sds_request *sci_req = object;
1549
1550 SET_STATE_HANDLER(
1551 sci_req,
1552 scic_sds_stp_request_started_soft_reset_substate_handler_table,
1553 SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_D2H_RESPONSE_FRAME_SUBSTATE
1554 );
1555 }
1556
1557 static const struct sci_base_state scic_sds_stp_request_started_soft_reset_substate_table[] = {
1558 [SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_ASSERTED_COMPLETION_SUBSTATE] = {
1559 .enter_state = scic_sds_stp_request_started_soft_reset_await_h2d_asserted_completion_enter,
1560 },
1561 [SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_DIAGNOSTIC_COMPLETION_SUBSTATE] = {
1562 .enter_state = scic_sds_stp_request_started_soft_reset_await_h2d_diagnostic_completion_enter,
1563 },
1564 [SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_D2H_RESPONSE_FRAME_SUBSTATE] = {
1565 .enter_state = scic_sds_stp_request_started_soft_reset_await_d2h_response_enter,
1566 },
1567 };
1568
1569 enum sci_status scic_sds_stp_soft_reset_request_construct(struct scic_sds_request *sci_req)
1570 {
1571 struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
1572
1573 scic_sds_stp_non_ncq_request_construct(sci_req);
1574
1575 /* Build the STP task context structure */
1576 scu_stp_raw_request_construct_task_context(stp_req, sci_req->task_context_buffer);
1577
1578 sci_base_state_machine_construct(&sci_req->started_substate_machine,
1579 sci_req,
1580 scic_sds_stp_request_started_soft_reset_substate_table,
1581 SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_ASSERTED_COMPLETION_SUBSTATE);
1582
1583 return SCI_SUCCESS;
1584 }
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree