request.h 21.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 266
	 *
	 * @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_req cmd;
			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;
}

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

	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 已提交
287
	unsigned int num_sg_entries;			/* returned by pci_alloc_sg */
288 289 290 291 292 293 294 295 296 297 298

	/** 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;
299
	struct scic_sds_request sci;
300 301
};

302 303 304 305 306 307 308
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;
}

309 310 311 312 313 314 315
/**
 * 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 已提交
316
	/*
317 318
	 * Simply the initial state for the base request state machine.
	 */
E
Edmund Nadolski 已提交
319
	SCI_REQ_INIT,
320

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

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

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

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

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

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

E
Edmund Nadolski 已提交
349 350 351 352
	/*
	 * 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.
353
	 */
E
Edmund Nadolski 已提交
354
	SCI_REQ_STP_PIO_WAIT_FRAME,
355

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

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

E
Edmund Nadolski 已提交
368
	/*
369 370 371 372
	 * 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 已提交
373
	SCI_REQ_TASK_WAIT_TC_COMP,
374

E
Edmund Nadolski 已提交
375
	/*
376 377 378 379
	 * 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 已提交
380
	SCI_REQ_TASK_WAIT_TC_RESP,
381

E
Edmund Nadolski 已提交
382
	/*
383 384 385 386
	 * 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 已提交
387
	SCI_REQ_SMP_WAIT_RESP,
388

E
Edmund Nadolski 已提交
389 390 391 392
	/*
	 * 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.).
393
	 */
E
Edmund Nadolski 已提交
394
	SCI_REQ_SMP_WAIT_TC_COMP,
395

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

E
Edmund Nadolski 已提交
403
	/*
404 405 406 407 408
	 * 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 已提交
409
	SCI_REQ_ABORTING,
410

E
Edmund Nadolski 已提交
411
	/*
412 413
	 * Simply the final state for the base request state machine.
	 */
E
Edmund Nadolski 已提交
414
	SCI_REQ_FINAL,
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 499
};

/**
 * 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 已提交
500 501 502 503 504 505 506 507 508 509 510 511
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);
512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529

/* 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 已提交
530 531
static inline dma_addr_t
scic_io_request_get_dma_addr(struct scic_sds_request *sci_req, void *virt_addr)
532 533 534 535 536 537 538 539 540 541 542 543
{
	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);
}

544 545 546 547 548 549
/**
 * 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 已提交
550 551
static inline enum isci_request_status
isci_request_get_state(struct isci_request *isci_request)
552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571
{
	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 已提交
572 573 574
static inline enum isci_request_status
isci_request_change_state(struct isci_request *isci_request,
			  enum isci_request_status status)
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 602
{
	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 已提交
603 604 605 606
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)
607 608 609 610 611 612 613 614
{
	enum isci_request_status old_state;
	unsigned long flags;

	spin_lock_irqsave(&isci_request->state_lock, flags);

	old_state = isci_request->status;

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

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

622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641
	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 已提交
642 643 644
static inline enum isci_request_status
isci_request_change_started_to_aborted(struct isci_request *isci_request,
				       struct completion *completion_ptr)
645
{
E
Edmund Nadolski 已提交
646 647 648
	return isci_request_change_started_to_newstate(isci_request,
						       completion_ptr,
						       aborted);
649 650 651 652 653 654 655
}
/**
 * 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 已提交
656 657
static inline void isci_request_free(struct isci_host *isci_host,
				     struct isci_request *isci_request)
658
{
659 660
	if (!isci_request)
		return;
661 662

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

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

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

D
Dan Williams 已提交
672 673 674
struct isci_request *isci_request_alloc_tmf(struct isci_host *ihost,
					    struct isci_tmf *isci_tmf,
					    gfp_t gfp_flags);
675

676 677
int isci_request_execute(struct isci_host *ihost, struct isci_remote_device *idev,
			 struct sas_task *task, gfp_t gfp_flags);
678 679 680 681 682 683 684 685

/**
 * isci_request_unmap_sgl() - This function unmaps the DMA address of a given
 *    sgl
 * @request: This parameter points to the isci_request object
 * @*pdev: This Parameter is the pci_device struct for the controller
 *
 */
E
Edmund Nadolski 已提交
686 687
static inline void
isci_request_unmap_sgl(struct isci_request *request, struct pci_dev *pdev)
688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729
{
	struct sas_task *task = isci_request_access_task(request);

	dev_dbg(&request->isci_host->pdev->dev,
		"%s: request = %p, task = %p,\n"
		"task->data_dir = %d, is_sata = %d\n ",
		__func__,
		request,
		task,
		task->data_dir,
		sas_protocol_ata(task->task_proto));

	if ((task->data_dir != PCI_DMA_NONE) &&
	    !sas_protocol_ata(task->task_proto)) {
		if (task->num_scatter == 0)
			/* 0 indicates a single dma address */
			dma_unmap_single(
				&pdev->dev,
				request->zero_scatter_daddr,
				task->total_xfer_len,
				task->data_dir
				);

		else  /* unmap the sgl dma addresses */
			dma_unmap_sg(
				&pdev->dev,
				task->scatter,
				request->num_sg_entries,
				task->data_dir
				);
	}
}

/**
 * isci_request_io_request_get_next_sge() - This function is called by the sci
 *    core to retrieve the next sge for a given request.
 * @request: This parameter is the isci_request object.
 * @current_sge_address: This parameter is the last sge retrieved by the sci
 *    core for this request.
 *
 * pointer to the next sge for specified request.
 */
E
Edmund Nadolski 已提交
730 731 732
static inline void *
isci_request_io_request_get_next_sge(struct isci_request *request,
				     void *current_sge_address)
733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762
{
	struct sas_task *task = isci_request_access_task(request);
	void *ret = NULL;

	dev_dbg(&request->isci_host->pdev->dev,
		"%s: request = %p, "
		"current_sge_address = %p, "
		"num_scatter = %d\n",
		__func__,
		request,
		current_sge_address,
		task->num_scatter);

	if (!current_sge_address)	/* First time through.. */
		ret = task->scatter;    /* always task->scatter */
	else if (task->num_scatter == 0) /* Next element, if num_scatter == 0 */
		ret = NULL;              /* there is only one element. */
	else
		ret = sg_next(current_sge_address);     /* sg_next returns NULL
							 * for the last element
							 */

	dev_dbg(&request->isci_host->pdev->dev,
		"%s: next sge address = %p\n",
		__func__,
		ret);

	return ret;
}

E
Edmund Nadolski 已提交
763
void
764 765
isci_terminate_pending_requests(struct isci_host *ihost,
				struct isci_remote_device *idev);
E
Edmund Nadolski 已提交
766 767 768 769 770 771 772 773 774 775 776
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);
777
void scic_sds_smp_request_copy_response(struct scic_sds_request *sci_req);
778
#endif /* !defined(_ISCI_REQUEST_H_) */