request.h 19.4 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55
/*
 * This file is provided under a dual BSD/GPLv2 license.  When using or
 * redistributing this file, you may do so under either license.
 *
 * GPL LICENSE SUMMARY
 *
 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
 * The full GNU General Public License is included in this distribution
 * in the file called LICENSE.GPL.
 *
 * BSD LICENSE
 *
 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in
 *     the documentation and/or other materials provided with the
 *     distribution.
 *   * Neither the name of Intel Corporation nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

56
#ifndef _ISCI_REQUEST_H_
57 58 59
#define _ISCI_REQUEST_H_

#include "isci.h"
D
Dan Williams 已提交
60
#include "host.h"
61
#include "scu_task_context.h"
62 63 64 65 66 67 68 69 70 71 72 73 74 75

/**
 * struct isci_request_status - This enum defines the possible states of an I/O
 *    request.
 *
 *
 */
enum isci_request_status {
	unallocated = 0x00,
	allocated   = 0x01,
	started     = 0x02,
	completed   = 0x03,
	aborting    = 0x04,
	aborted     = 0x05,
76 77
	terminating = 0x06,
	dead        = 0x07
78 79 80 81 82 83 84
};

enum task_type {
	io_task  = 0,
	tmf_task = 1
};

85 86 87 88 89
enum sci_request_protocol {
	SCIC_NO_PROTOCOL,
	SCIC_SMP_PROTOCOL,
	SCIC_SSP_PROTOCOL,
	SCIC_STP_PROTOCOL
90
}; /* XXX remove me, use sas_task.{dev|task_proto} instead */;
91

92 93 94 95 96 97 98
struct scic_sds_stp_request {
	union {
		u32 ncq;

		u32 udma;

		struct scic_sds_stp_pio_request {
E
Edmund Nadolski 已提交
99 100 101
			/*
			 * Total transfer for the entire PIO request recorded
			 * at request constuction time.
102
			 *
E
Edmund Nadolski 已提交
103 104 105
			 * @todo Should we just decrement this value for each
			 * byte of data transitted or received to elemenate
			 * the current_transfer_bytes field?
106 107 108
			 */
			u32 total_transfer_bytes;

E
Edmund Nadolski 已提交
109 110 111 112
			/*
			 * Total number of bytes received/transmitted in data
			 * frames since the start of the IO request.  At the
			 * end of the IO request this should equal the
113 114 115 116
			 * total_transfer_bytes.
			 */
			u32 current_transfer_bytes;

E
Edmund Nadolski 已提交
117 118 119
			/*
			 * The number of bytes requested in the in the PIO
			 * setup.
120 121 122
			 */
			u32 pio_transfer_bytes;

E
Edmund Nadolski 已提交
123 124 125 126
			/*
			 * PIO Setup ending status value to tell us if we need
			 * to wait for another FIS or if the transfer is
			 * complete. On the receipt of a D2H FIS this will be
127 128 129 130
			 * the status field of that FIS.
			 */
			u8 ending_status;

E
Edmund Nadolski 已提交
131 132 133 134
			/*
			 * On receipt of a D2H FIS this will be the ending
			 * error field if the ending_status has the
			 * SATA_STATUS_ERR bit set.
135 136 137 138 139 140 141 142 143 144 145
			 */
			u8 ending_error;

			struct scic_sds_request_pio_sgl {
				struct scu_sgl_element_pair *sgl_pair;
				u8 sgl_set;
				u32 sgl_offset;
			} request_current;
		} pio;

		struct {
E
Edmund Nadolski 已提交
146 147 148
			/*
			 * The number of bytes requested in the PIO setup
			 * before CDB data frame.
149 150 151 152 153 154
			 */
			u32 device_preferred_cdb_length;
		} packet;
	} type;
};

155
struct scic_sds_request {
E
Edmund Nadolski 已提交
156 157 158
	/*
	 * This field contains the information for the base request state
	 * machine.
159
	 */
E
Edmund Nadolski 已提交
160
	struct sci_base_state_machine sm;
161

E
Edmund Nadolski 已提交
162
	/*
163 164 165 166 167
	 * This field simply points to the controller to which this IO request
	 * is associated.
	 */
	struct scic_sds_controller *owning_controller;

E
Edmund Nadolski 已提交
168 169 170
	/*
	 * This field simply points to the remote device to which this IO
	 * request is associated.
171 172 173
	 */
	struct scic_sds_remote_device *target_device;

E
Edmund Nadolski 已提交
174
	/*
175 176 177 178 179
	 * This field is utilized to determine if the SCI user is managing
	 * the IO tag for this request or if the core is managing it.
	 */
	bool was_tag_assigned_by_user;

E
Edmund Nadolski 已提交
180
	/*
181 182 183 184 185 186
	 * This field indicates the IO tag for this request.  The IO tag is
	 * comprised of the task_index and a sequence count. The sequence count
	 * is utilized to help identify tasks from one life to another.
	 */
	u16 io_tag;

E
Edmund Nadolski 已提交
187
	/*
188 189 190 191 192
	 * This field specifies the protocol being utilized for this
	 * IO request.
	 */
	enum sci_request_protocol protocol;

E
Edmund Nadolski 已提交
193
	/*
194
	 * This field indicates the completion status taken from the SCUs
E
Edmund Nadolski 已提交
195 196
	 * completion code.  It indicates the completion result for the SCU
	 * hardware.
197 198 199
	 */
	u32 scu_status;

E
Edmund Nadolski 已提交
200 201 202
	/*
	 * This field indicates the completion status returned to the SCI user.
	 * It indicates the users view of the io request completion.
203 204 205
	 */
	u32 sci_status;

E
Edmund Nadolski 已提交
206 207 208
	/*
	 * This field contains the value to be utilized when posting
	 * (e.g. Post_TC, * Post_TC_Abort) this request to the silicon.
209 210 211 212 213 214 215
	 */
	u32 post_context;

	struct scu_task_context *task_context_buffer;
	struct scu_task_context tc ____cacheline_aligned;

	/* could be larger with sg chaining */
216
	#define SCU_SGL_SIZE ((SCI_MAX_SCATTER_GATHER_ELEMENTS + 1) / 2)
217 218
	struct scu_sgl_element_pair sg_table[SCU_SGL_SIZE] __attribute__ ((aligned(32)));

E
Edmund Nadolski 已提交
219
	/*
220 221 222 223 224
	 * This field indicates if this request is a task management request or
	 * normal IO request.
	 */
	bool is_task_management_request;

E
Edmund Nadolski 已提交
225 226 227 228
	/*
	 * This field is a pointer to the stored rx frame data.  It is used in
	 * STP internal requests and SMP response frames.  If this field is
	 * non-NULL the saved frame must be released on IO request completion.
229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265
	 *
	 * @todo In the future do we want to keep a list of RX frame buffers?
	 */
	u32 saved_rx_frame_index;

	union {
		struct {
			union {
				struct ssp_cmd_iu cmd;
				struct ssp_task_iu tmf;
			};
			union {
				struct ssp_response_iu rsp;
				u8 rsp_buf[SSP_RESP_IU_MAX_SIZE];
			};
		} ssp;

		struct {
			struct smp_resp rsp;
		} smp;

		struct {
			struct scic_sds_stp_request req;
			struct host_to_dev_fis cmd;
			struct dev_to_host_fis rsp;
		} stp;
	};
};

static inline struct scic_sds_request *to_sci_req(struct scic_sds_stp_request *stp_req)
{
	struct scic_sds_request *sci_req;

	sci_req = container_of(stp_req, typeof(*sci_req), stp.req);
	return sci_req;
}

266 267 268 269 270
struct isci_request {
	enum isci_request_status status;
	enum task_type ttype;
	unsigned short io_tag;
	bool complete_in_target;
271
	bool terminated;
272 273 274 275 276 277 278 279 280 281 282 283 284 285

	union ttype_ptr_union {
		struct sas_task *io_task_ptr;   /* When ttype==io_task  */
		struct isci_tmf *tmf_task_ptr;  /* When ttype==tmf_task */
	} ttype_ptr;
	struct isci_host *isci_host;
	/* For use in the requests_to_{complete|abort} lists: */
	struct list_head completed_node;
	/* For use in the reqs_in_process list: */
	struct list_head dev_node;
	spinlock_t state_lock;
	dma_addr_t request_daddr;
	dma_addr_t zero_scatter_daddr;

E
Edmund Nadolski 已提交
286
	unsigned int num_sg_entries;			/* returned by pci_alloc_sg */
287 288 289 290 291 292 293 294 295 296 297

	/** Note: "io_request_completion" is completed in two different ways
	 * depending on whether this is a TMF or regular request.
	 * - TMF requests are completed in the thread that started them;
	 * - regular requests are completed in the request completion callback
	 *   function.
	 * This difference in operation allows the aborter of a TMF request
	 * to be sure that once the TMF request completes, the I/O that the
	 * TMF was aborting is guaranteed to have completed.
	 */
	struct completion *io_request_completion;
298
	struct scic_sds_request sci;
299 300
};

301 302 303 304 305 306 307
static inline struct isci_request *sci_req_to_ireq(struct scic_sds_request *sci_req)
{
	struct isci_request *ireq = container_of(sci_req, typeof(*ireq), sci);

	return ireq;
}

308 309 310 311 312 313 314
/**
 * enum sci_base_request_states - This enumeration depicts all the states for
 *    the common request state machine.
 *
 *
 */
enum sci_base_request_states {
E
Edmund Nadolski 已提交
315
	/*
316 317
	 * Simply the initial state for the base request state machine.
	 */
E
Edmund Nadolski 已提交
318
	SCI_REQ_INIT,
319

E
Edmund Nadolski 已提交
320 321 322
	/*
	 * This state indicates that the request has been constructed.
	 * This state is entered from the INITIAL state.
323
	 */
E
Edmund Nadolski 已提交
324
	SCI_REQ_CONSTRUCTED,
325

E
Edmund Nadolski 已提交
326 327 328
	/*
	 * This state indicates that the request has been started. This state
	 * is entered from the CONSTRUCTED state.
329
	 */
E
Edmund Nadolski 已提交
330
	SCI_REQ_STARTED,
331

E
Edmund Nadolski 已提交
332 333
	SCI_REQ_STP_UDMA_WAIT_TC_COMP,
	SCI_REQ_STP_UDMA_WAIT_D2H,
334

E
Edmund Nadolski 已提交
335 336
	SCI_REQ_STP_NON_DATA_WAIT_H2D,
	SCI_REQ_STP_NON_DATA_WAIT_D2H,
337

E
Edmund Nadolski 已提交
338 339 340
	SCI_REQ_STP_SOFT_RESET_WAIT_H2D_ASSERTED,
	SCI_REQ_STP_SOFT_RESET_WAIT_H2D_DIAG,
	SCI_REQ_STP_SOFT_RESET_WAIT_D2H,
341

E
Edmund Nadolski 已提交
342 343 344
	/*
	 * While in this state the IO request object is waiting for the TC
	 * completion notification for the H2D Register FIS
345
	 */
E
Edmund Nadolski 已提交
346
	SCI_REQ_STP_PIO_WAIT_H2D,
347

E
Edmund Nadolski 已提交
348 349 350 351
	/*
	 * While in this state the IO request object is waiting for either a
	 * PIO Setup FIS or a D2H register FIS.  The type of frame received is
	 * based on the result of the prior frame and line conditions.
352
	 */
E
Edmund Nadolski 已提交
353
	SCI_REQ_STP_PIO_WAIT_FRAME,
354

E
Edmund Nadolski 已提交
355 356 357
	/*
	 * While in this state the IO request object is waiting for a DATA
	 * frame from the device.
358
	 */
E
Edmund Nadolski 已提交
359
	SCI_REQ_STP_PIO_DATA_IN,
360

E
Edmund Nadolski 已提交
361 362 363
	/*
	 * While in this state the IO request object is waiting to transmit
	 * the next data frame to the device.
364
	 */
E
Edmund Nadolski 已提交
365
	SCI_REQ_STP_PIO_DATA_OUT,
366

E
Edmund Nadolski 已提交
367
	/*
368 369 370 371
	 * The AWAIT_TC_COMPLETION sub-state indicates that the started raw
	 * task management request is waiting for the transmission of the
	 * initial frame (i.e. command, task, etc.).
	 */
E
Edmund Nadolski 已提交
372
	SCI_REQ_TASK_WAIT_TC_COMP,
373

E
Edmund Nadolski 已提交
374
	/*
375 376 377 378
	 * This sub-state indicates that the started task management request
	 * is waiting for the reception of an unsolicited frame
	 * (i.e. response IU).
	 */
E
Edmund Nadolski 已提交
379
	SCI_REQ_TASK_WAIT_TC_RESP,
380

E
Edmund Nadolski 已提交
381
	/*
382 383 384 385
	 * This sub-state indicates that the started task management request
	 * is waiting for the reception of an unsolicited frame
	 * (i.e. response IU).
	 */
E
Edmund Nadolski 已提交
386
	SCI_REQ_SMP_WAIT_RESP,
387

E
Edmund Nadolski 已提交
388 389 390 391
	/*
	 * The AWAIT_TC_COMPLETION sub-state indicates that the started SMP
	 * request is waiting for the transmission of the initial frame
	 * (i.e. command, task, etc.).
392
	 */
E
Edmund Nadolski 已提交
393
	SCI_REQ_SMP_WAIT_TC_COMP,
394

E
Edmund Nadolski 已提交
395
	/*
396
	 * This state indicates that the request has completed.
E
Edmund Nadolski 已提交
397 398
	 * This state is entered from the STARTED state. This state is entered
	 * from the ABORTING state.
399
	 */
E
Edmund Nadolski 已提交
400
	SCI_REQ_COMPLETED,
401

E
Edmund Nadolski 已提交
402
	/*
403 404 405 406 407
	 * This state indicates that the request is in the process of being
	 * terminated/aborted.
	 * This state is entered from the CONSTRUCTED state.
	 * This state is entered from the STARTED state.
	 */
E
Edmund Nadolski 已提交
408
	SCI_REQ_ABORTING,
409

E
Edmund Nadolski 已提交
410
	/*
411 412
	 * Simply the final state for the base request state machine.
	 */
E
Edmund Nadolski 已提交
413
	SCI_REQ_FINAL,
414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498
};

/**
 * scic_sds_request_get_controller() -
 *
 * This macro will return the controller for this io request object
 */
#define scic_sds_request_get_controller(sci_req) \
	((sci_req)->owning_controller)

/**
 * scic_sds_request_get_device() -
 *
 * This macro will return the device for this io request object
 */
#define scic_sds_request_get_device(sci_req) \
	((sci_req)->target_device)

/**
 * scic_sds_request_get_port() -
 *
 * This macro will return the port for this io request object
 */
#define scic_sds_request_get_port(sci_req)	\
	scic_sds_remote_device_get_port(scic_sds_request_get_device(sci_req))

/**
 * scic_sds_request_get_post_context() -
 *
 * This macro returns the constructed post context result for the io request.
 */
#define scic_sds_request_get_post_context(sci_req)	\
	((sci_req)->post_context)

/**
 * scic_sds_request_get_task_context() -
 *
 * This is a helper macro to return the os handle for this request object.
 */
#define scic_sds_request_get_task_context(request) \
	((request)->task_context_buffer)

/**
 * scic_sds_request_set_status() -
 *
 * This macro will set the scu hardware status and sci request completion
 * status for an io request.
 */
#define scic_sds_request_set_status(request, scu_status_code, sci_status_code) \
	{ \
		(request)->scu_status = (scu_status_code); \
		(request)->sci_status = (sci_status_code); \
	}

/**
 * SCU_SGL_ZERO() -
 *
 * This macro zeros the hardware SGL element data
 */
#define SCU_SGL_ZERO(scu_sge) \
	{ \
		(scu_sge).length = 0; \
		(scu_sge).address_lower = 0; \
		(scu_sge).address_upper = 0; \
		(scu_sge).address_modifier = 0;	\
	}

/**
 * SCU_SGL_COPY() -
 *
 * This macro copys the SGL Element data from the host os to the hardware SGL
 * elment data
 */
#define SCU_SGL_COPY(scu_sge, os_sge) \
	{ \
		(scu_sge).length = sg_dma_len(sg); \
		(scu_sge).address_upper = \
			upper_32_bits(sg_dma_address(sg)); \
		(scu_sge).address_lower = \
			lower_32_bits(sg_dma_address(sg)); \
		(scu_sge).address_modifier = 0;	\
	}

enum sci_status scic_sds_request_start(struct scic_sds_request *sci_req);
enum sci_status scic_sds_io_request_terminate(struct scic_sds_request *sci_req);
E
Edmund Nadolski 已提交
499 500 501 502 503 504 505 506 507 508 509 510
enum sci_status
scic_sds_io_request_event_handler(struct scic_sds_request *sci_req,
				  u32 event_code);
enum sci_status
scic_sds_io_request_frame_handler(struct scic_sds_request *sci_req,
				  u32 frame_index);
enum sci_status
scic_sds_task_request_terminate(struct scic_sds_request *sci_req);
extern enum sci_status
scic_sds_request_complete(struct scic_sds_request *sci_req);
extern enum sci_status
scic_sds_io_request_tc_completion(struct scic_sds_request *sci_req, u32 code);
511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528

/* XXX open code in caller */
static inline void *scic_request_get_virt_addr(struct scic_sds_request *sci_req,
					       dma_addr_t phys_addr)
{
	struct isci_request *ireq = sci_req_to_ireq(sci_req);
	dma_addr_t offset;

	BUG_ON(phys_addr < ireq->request_daddr);

	offset = phys_addr - ireq->request_daddr;

	BUG_ON(offset >= sizeof(*ireq));

	return (char *)ireq + offset;
}

/* XXX open code in caller */
E
Edmund Nadolski 已提交
529 530
static inline dma_addr_t
scic_io_request_get_dma_addr(struct scic_sds_request *sci_req, void *virt_addr)
531 532 533 534 535 536 537 538 539 540 541 542
{
	struct isci_request *ireq = sci_req_to_ireq(sci_req);

	char *requested_addr = (char *)virt_addr;
	char *base_addr = (char *)ireq;

	BUG_ON(requested_addr < base_addr);
	BUG_ON((requested_addr - base_addr) >= sizeof(*ireq));

	return ireq->request_daddr + (requested_addr - base_addr);
}

543 544 545 546 547 548
/**
 * This function gets the status of the request object.
 * @request: This parameter points to the isci_request object
 *
 * status of the object as a isci_request_status enum.
 */
E
Edmund Nadolski 已提交
549 550
static inline enum isci_request_status
isci_request_get_state(struct isci_request *isci_request)
551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570
{
	BUG_ON(isci_request == NULL);

	/*probably a bad sign...	*/
	if (isci_request->status == unallocated)
		dev_warn(&isci_request->isci_host->pdev->dev,
			 "%s: isci_request->status == unallocated\n",
			 __func__);

	return isci_request->status;
}


/**
 * isci_request_change_state() - This function sets the status of the request
 *    object.
 * @request: This parameter points to the isci_request object
 * @status: This Parameter is the new status of the object
 *
 */
E
Edmund Nadolski 已提交
571 572 573
static inline enum isci_request_status
isci_request_change_state(struct isci_request *isci_request,
			  enum isci_request_status status)
574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601
{
	enum isci_request_status old_state;
	unsigned long flags;

	dev_dbg(&isci_request->isci_host->pdev->dev,
		"%s: isci_request = %p, state = 0x%x\n",
		__func__,
		isci_request,
		status);

	BUG_ON(isci_request == NULL);

	spin_lock_irqsave(&isci_request->state_lock, flags);
	old_state = isci_request->status;
	isci_request->status = status;
	spin_unlock_irqrestore(&isci_request->state_lock, flags);

	return old_state;
}

/**
 * isci_request_change_started_to_newstate() - This function sets the status of
 *    the request object.
 * @request: This parameter points to the isci_request object
 * @status: This Parameter is the new status of the object
 *
 * state previous to any change.
 */
E
Edmund Nadolski 已提交
602 603 604 605
static inline enum isci_request_status
isci_request_change_started_to_newstate(struct isci_request *isci_request,
					struct completion *completion_ptr,
					enum isci_request_status newstate)
606 607 608 609 610 611 612 613
{
	enum isci_request_status old_state;
	unsigned long flags;

	spin_lock_irqsave(&isci_request->state_lock, flags);

	old_state = isci_request->status;

614
	if (old_state == started || old_state == aborting) {
615 616 617 618 619
		BUG_ON(isci_request->io_request_completion != NULL);

		isci_request->io_request_completion = completion_ptr;
		isci_request->status = newstate;
	}
E
Edmund Nadolski 已提交
620

621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640
	spin_unlock_irqrestore(&isci_request->state_lock, flags);

	dev_dbg(&isci_request->isci_host->pdev->dev,
		"%s: isci_request = %p, old_state = 0x%x\n",
		__func__,
		isci_request,
		old_state);

	return old_state;
}

/**
 * isci_request_change_started_to_aborted() - This function sets the status of
 *    the request object.
 * @request: This parameter points to the isci_request object
 * @completion_ptr: This parameter is saved as the kernel completion structure
 *    signalled when the old request completes.
 *
 * state previous to any change.
 */
E
Edmund Nadolski 已提交
641 642 643
static inline enum isci_request_status
isci_request_change_started_to_aborted(struct isci_request *isci_request,
				       struct completion *completion_ptr)
644
{
E
Edmund Nadolski 已提交
645 646 647
	return isci_request_change_started_to_newstate(isci_request,
						       completion_ptr,
						       aborted);
648 649 650 651 652 653 654
}
/**
 * isci_request_free() - This function frees the request object.
 * @isci_host: This parameter specifies the ISCI host object
 * @isci_request: This parameter points to the isci_request object
 *
 */
E
Edmund Nadolski 已提交
655 656
static inline void isci_request_free(struct isci_host *isci_host,
				     struct isci_request *isci_request)
657
{
658 659
	if (!isci_request)
		return;
660 661

	/* release the dma memory if we fail. */
E
Edmund Nadolski 已提交
662 663
	dma_pool_free(isci_host->dma_pool,
		      isci_request,
664 665 666
		      isci_request->request_daddr);
}

E
Edmund Nadolski 已提交
667
#define isci_request_access_task(req) ((req)->ttype_ptr.io_task_ptr)
668

E
Edmund Nadolski 已提交
669
#define isci_request_access_tmf(req) ((req)->ttype_ptr.tmf_task_ptr)
670

D
Dan Williams 已提交
671 672 673
struct isci_request *isci_request_alloc_tmf(struct isci_host *ihost,
					    struct isci_tmf *isci_tmf,
					    gfp_t gfp_flags);
674 675
int isci_request_execute(struct isci_host *ihost, struct isci_remote_device *idev,
			 struct sas_task *task, gfp_t gfp_flags);
D
Dan Williams 已提交
676 677
void isci_terminate_pending_requests(struct isci_host *ihost,
				     struct isci_remote_device *idev);
E
Edmund Nadolski 已提交
678 679 680 681 682 683 684 685 686 687 688
enum sci_status
scic_task_request_construct(struct scic_sds_controller *scic,
			    struct scic_sds_remote_device *sci_dev,
			    u16 io_tag,
			    struct scic_sds_request *sci_req);
enum sci_status
scic_task_request_construct_ssp(struct scic_sds_request *sci_req);
enum sci_status
scic_task_request_construct_sata(struct scic_sds_request *sci_req);
void
scic_stp_io_request_set_ncq_tag(struct scic_sds_request *sci_req, u16 ncq_tag);
689
void scic_sds_smp_request_copy_response(struct scic_sds_request *sci_req);
690 691 692 693 694 695 696 697 698

static inline int isci_task_is_ncq_recovery(struct sas_task *task)
{
	return (sas_protocol_ata(task->task_proto) &&
	        task->ata_task.fis.command == ATA_CMD_READ_LOG_EXT &&
	        task->ata_task.fis.lbal == ATA_LOG_SATA_NCQ);

}

699
#endif /* !defined(_ISCI_REQUEST_H_) */