*
* Private operation for the pool
*/
-#define SCI_POOL_INCREMENT(this_pool, index) \
- (((index) + 1) == (this_pool).size ? 0 : (index) + 1)
+#define SCI_POOL_INCREMENT(pool, index) \
+ (((index) + 1) == (pool).size ? 0 : (index) + 1)
/**
* SCI_POOL_CREATE() -
* This macro evaluates the pool and returns true if the pool is empty. If the
* pool is empty the user should not perform any get operation on the pool.
*/
-#define sci_pool_empty(this_pool) \
- ((this_pool).get == (this_pool).put)
+#define sci_pool_empty(pool) \
+ ((pool).get == (pool).put)
/**
* sci_pool_full() -
* This macro evaluates the pool and returns true if the pool is full. If the
* pool is full the user should not perform any put operation.
*/
-#define sci_pool_full(this_pool) \
- (SCI_POOL_INCREMENT(this_pool, (this_pool).put) == (this_pool).get)
+#define sci_pool_full(pool) \
+ (SCI_POOL_INCREMENT(pool, (pool).put) == (pool).get)
/**
* sci_pool_size() -
* pointers can be written simultaneously by different users. As a result,
* this macro subtracts 1 from the internal size
*/
-#define sci_pool_size(this_pool) \
- ((this_pool).size - 1)
+#define sci_pool_size(pool) \
+ ((pool).size - 1)
/**
* sci_pool_count() -
*
* This macro indicates the number of elements currently contained in the pool.
*/
-#define sci_pool_count(this_pool) \
+#define sci_pool_count(pool) \
(\
- sci_pool_empty((this_pool)) \
+ sci_pool_empty((pool)) \
? 0 \
: (\
- sci_pool_full((this_pool)) \
- ? sci_pool_size((this_pool)) \
+ sci_pool_full((pool)) \
+ ? sci_pool_size((pool)) \
: (\
- (this_pool).get > (this_pool).put \
- ? ((this_pool).size - (this_pool).get + (this_pool).put) \
- : ((this_pool).put - (this_pool).get) \
+ (pool).get > (pool).put \
+ ? ((pool).size - (pool).get + (pool).put) \
+ : ((pool).put - (pool).get) \
) \
) \
)
*
* This macro initializes the pool to an empty condition.
*/
-#define sci_pool_initialize(this_pool) \
+#define sci_pool_initialize(pool) \
{ \
- (this_pool).size = (sizeof((this_pool).array) / sizeof((this_pool).array[0])); \
- (this_pool).get = 0; \
- (this_pool).put = 0; \
+ (pool).size = (sizeof((pool).array) / sizeof((pool).array[0])); \
+ (pool).get = 0; \
+ (pool).put = 0; \
}
/**
* This macro will get the next free element from the pool. This should only be
* called if the pool is not empty.
*/
-#define sci_pool_get(this_pool, my_value) \
+#define sci_pool_get(pool, my_value) \
{ \
- (my_value) = (this_pool).array[(this_pool).get]; \
- (this_pool).get = SCI_POOL_INCREMENT((this_pool), (this_pool).get); \
+ (my_value) = (pool).array[(pool).get]; \
+ (pool).get = SCI_POOL_INCREMENT((pool), (pool).get); \
}
/**
* This macro will put the value into the pool. This should only be called if
* the pool is not full.
*/
-#define sci_pool_put(this_pool, the_value) \
+#define sci_pool_put(pool, value) \
{ \
- (this_pool).array[(this_pool).put] = (the_value); \
- (this_pool).put = SCI_POOL_INCREMENT((this_pool), (this_pool).put); \
+ (pool).array[(pool).put] = (value); \
+ (pool).put = SCI_POOL_INCREMENT((pool), (pool).put); \
}
/**
* This macro will search the pool and remove any elements in the pool matching
* the supplied value. This method can only be utilized on pools
*/
-#define sci_pool_erase(this_pool, type, the_value) \
+#define sci_pool_erase(pool, type, value) \
{ \
type tmp_value; \
u32 index; \
- u32 element_count = sci_pool_count((this_pool)); \
+ u32 element_count = sci_pool_count((pool)); \
\
for (index = 0; index < element_count; index++) { \
- sci_pool_get((this_pool), tmp_value); \
- if (tmp_value != (the_value)) \
- sci_pool_put((this_pool), tmp_value); \
+ sci_pool_get((pool), tmp_value); \
+ if (tmp_value != (value)) \
+ sci_pool_put((pool), tmp_value); \
} \
}
/**
* This method initializes the task context data for the controller.
- * @this_controller:
+ * @scic:
*
*/
static void
*
*/
static void scic_sds_controller_initialize_completion_queue(
- struct scic_sds_controller *this_controller)
+ struct scic_sds_controller *scic)
{
u32 index;
u32 completion_queue_control_value;
u32 completion_queue_get_value;
u32 completion_queue_put_value;
- this_controller->completion_queue_get = 0;
+ scic->completion_queue_get = 0;
completion_queue_control_value = (
- SMU_CQC_QUEUE_LIMIT_SET(this_controller->completion_queue_entries - 1)
- | SMU_CQC_EVENT_LIMIT_SET(this_controller->completion_event_entries - 1)
+ SMU_CQC_QUEUE_LIMIT_SET(scic->completion_queue_entries - 1)
+ | SMU_CQC_EVENT_LIMIT_SET(scic->completion_event_entries - 1)
);
writel(completion_queue_control_value,
- &this_controller->smu_registers->completion_queue_control);
+ &scic->smu_registers->completion_queue_control);
/* Set the completion queue get pointer and enable the queue */
);
writel(completion_queue_get_value,
- &this_controller->smu_registers->completion_queue_get);
+ &scic->smu_registers->completion_queue_get);
/* Set the completion queue put pointer */
completion_queue_put_value = (
);
writel(completion_queue_put_value,
- &this_controller->smu_registers->completion_queue_put);
-
+ &scic->smu_registers->completion_queue_put);
/* Initialize the cycle bit of the completion queue entries */
- for (index = 0; index < this_controller->completion_queue_entries; index++) {
+ for (index = 0; index < scic->completion_queue_entries; index++) {
/*
* If get.cycle_bit != completion_queue.cycle_bit
* its not a valid completion queue entry
* so at system start all entries are invalid */
- this_controller->completion_queue[index] = 0x80000000;
+ scic->completion_queue[index] = 0x80000000;
}
}
*
*/
static void scic_sds_controller_initialize_unsolicited_frame_queue(
- struct scic_sds_controller *this_controller)
+ struct scic_sds_controller *scic)
{
u32 frame_queue_control_value;
u32 frame_queue_get_value;
/* Write the queue size */
frame_queue_control_value =
- SCU_UFQC_GEN_VAL(QUEUE_SIZE, this_controller->uf_control.address_table.count);
+ SCU_UFQC_GEN_VAL(QUEUE_SIZE,
+ scic->uf_control.address_table.count);
writel(frame_queue_control_value,
- &this_controller->scu_registers->sdma.unsolicited_frame_queue_control);
+ &scic->scu_registers->sdma.unsolicited_frame_queue_control);
/* Setup the get pointer for the unsolicited frame queue */
frame_queue_get_value = (
);
writel(frame_queue_get_value,
- &this_controller->scu_registers->sdma.unsolicited_frame_get_pointer);
+ &scic->scu_registers->sdma.unsolicited_frame_get_pointer);
/* Setup the put pointer for the unsolicited frame queue */
frame_queue_put_value = SCU_UFQPP_GEN_VAL(POINTER, 0);
writel(frame_queue_put_value,
- &this_controller->scu_registers->sdma.unsolicited_frame_put_pointer);
+ &scic->scu_registers->sdma.unsolicited_frame_put_pointer);
}
/**
*
*/
static void scic_sds_controller_enable_port_task_scheduler(
- struct scic_sds_controller *this_controller)
+ struct scic_sds_controller *scic)
{
u32 port_task_scheduler_value;
port_task_scheduler_value =
- readl(&this_controller->scu_registers->peg0.ptsg.control);
+ readl(&scic->scu_registers->peg0.ptsg.control);
port_task_scheduler_value |=
- (SCU_PTSGCR_GEN_BIT(ETM_ENABLE) | SCU_PTSGCR_GEN_BIT(PTSG_ENABLE));
+ (SCU_PTSGCR_GEN_BIT(ETM_ENABLE) |
+ SCU_PTSGCR_GEN_BIT(PTSG_ENABLE));
writel(port_task_scheduler_value,
- &this_controller->scu_registers->peg0.ptsg.control);
+ &scic->scu_registers->peg0.ptsg.control);
}
/**
* This method will attempt to transition into the ready state for the
* controller and indicate that the controller start operation has completed
* if all criteria are met.
- * @this_controller: This parameter indicates the controller object for which
+ * @scic: This parameter indicates the controller object for which
* to transition to ready.
* @status: This parameter indicates the status value to be pass into the call
* to scic_cb_controller_start_complete().
static void scic_sds_controller_power_control_timer_handler(
void *controller)
{
- struct scic_sds_controller *this_controller;
+ struct scic_sds_controller *scic;
- this_controller = (struct scic_sds_controller *)controller;
+ scic = (struct scic_sds_controller *)controller;
- this_controller->power_control.phys_granted_power = 0;
+ scic->power_control.phys_granted_power = 0;
- if (this_controller->power_control.phys_waiting == 0) {
- this_controller->power_control.timer_started = false;
+ if (scic->power_control.phys_waiting == 0) {
+ scic->power_control.timer_started = false;
} else {
- struct scic_sds_phy *the_phy = NULL;
+ struct scic_sds_phy *sci_phy = NULL;
u8 i;
for (i = 0;
(i < SCI_MAX_PHYS)
- && (this_controller->power_control.phys_waiting != 0);
+ && (scic->power_control.phys_waiting != 0);
i++) {
- if (this_controller->power_control.requesters[i] != NULL) {
- if (this_controller->power_control.phys_granted_power <
- this_controller->oem_parameters.sds1.controller.max_concurrent_dev_spin_up) {
- the_phy = this_controller->power_control.requesters[i];
- this_controller->power_control.requesters[i] = NULL;
- this_controller->power_control.phys_waiting--;
- this_controller->power_control.phys_granted_power++;
- scic_sds_phy_consume_power_handler(the_phy);
+ if (scic->power_control.requesters[i] != NULL) {
+ if (scic->power_control.phys_granted_power <
+ scic->oem_parameters.sds1.controller.max_concurrent_dev_spin_up) {
+ sci_phy = scic->power_control.requesters[i];
+ scic->power_control.requesters[i] = NULL;
+ scic->power_control.phys_waiting--;
+ scic->power_control.phys_granted_power++;
+ scic_sds_phy_consume_power_handler(sci_phy);
} else {
break;
}
* It doesn't matter if the power list is empty, we need to start the
* timer in case another phy becomes ready.
*/
- scic_sds_controller_power_control_timer_start(this_controller);
+ scic_sds_controller_power_control_timer_start(scic);
}
}
/**
* This method inserts the phy in the stagger spinup control queue.
- * @this_controller:
+ * @scic:
*
*
*/
void scic_sds_controller_power_control_queue_insert(
- struct scic_sds_controller *this_controller,
- struct scic_sds_phy *the_phy)
+ struct scic_sds_controller *scic,
+ struct scic_sds_phy *sci_phy)
{
- BUG_ON(the_phy == NULL);
+ BUG_ON(sci_phy == NULL);
- if (this_controller->power_control.phys_granted_power <
- this_controller->oem_parameters.sds1.controller.max_concurrent_dev_spin_up) {
- this_controller->power_control.phys_granted_power++;
- scic_sds_phy_consume_power_handler(the_phy);
+ if (scic->power_control.phys_granted_power <
+ scic->oem_parameters.sds1.controller.max_concurrent_dev_spin_up) {
+ scic->power_control.phys_granted_power++;
+ scic_sds_phy_consume_power_handler(sci_phy);
/*
* stop and start the power_control timer. When the timer fires, the
* no_of_phys_granted_power will be set to 0
*/
- scic_sds_controller_power_control_timer_restart(this_controller);
+ scic_sds_controller_power_control_timer_restart(scic);
} else {
/* Add the phy in the waiting list */
- this_controller->power_control.requesters[the_phy->phy_index] = the_phy;
- this_controller->power_control.phys_waiting++;
+ scic->power_control.requesters[sci_phy->phy_index] = sci_phy;
+ scic->power_control.phys_waiting++;
}
}
/**
* This method removes the phy from the stagger spinup control queue.
- * @this_controller:
+ * @scic:
*
*
*/
void scic_sds_controller_power_control_queue_remove(
- struct scic_sds_controller *this_controller,
- struct scic_sds_phy *the_phy)
+ struct scic_sds_controller *scic,
+ struct scic_sds_phy *sci_phy)
{
- BUG_ON(the_phy == NULL);
+ BUG_ON(sci_phy == NULL);
- if (this_controller->power_control.requesters[the_phy->phy_index] != NULL) {
- this_controller->power_control.phys_waiting--;
+ if (scic->power_control.requesters[sci_phy->phy_index] != NULL) {
+ scic->power_control.phys_waiting--;
}
- this_controller->power_control.requesters[the_phy->phy_index] = NULL;
+ scic->power_control.requesters[sci_phy->phy_index] = NULL;
}
/*
/**
* This method returns a true value if the completion queue has entries that
* can be processed
- * @this_controller:
+ * @scic:
*
* bool true if the completion queue has entries to process false if the
* completion queue has no entries to process
*/
static bool scic_sds_controller_completion_queue_has_entries(
- struct scic_sds_controller *this_controller)
+ struct scic_sds_controller *scic)
{
- u32 get_value = this_controller->completion_queue_get;
+ u32 get_value = scic->completion_queue_get;
u32 get_index = get_value & SMU_COMPLETION_QUEUE_GET_POINTER_MASK;
- if (
- NORMALIZE_GET_POINTER_CYCLE_BIT(get_value)
- == COMPLETION_QUEUE_CYCLE_BIT(this_controller->completion_queue[get_index])
- ) {
+ if (NORMALIZE_GET_POINTER_CYCLE_BIT(get_value) ==
+ COMPLETION_QUEUE_CYCLE_BIT(scic->completion_queue[get_index]))
return true;
- }
return false;
}
/**
* This method processes a task completion notification. This is called from
* within the controller completion handler.
- * @this_controller:
+ * @scic:
* @completion_entry:
*
*/
static void scic_sds_controller_task_completion(
- struct scic_sds_controller *this_controller,
+ struct scic_sds_controller *scic,
u32 completion_entry)
{
u32 index;
struct scic_sds_request *io_request;
index = SCU_GET_COMPLETION_INDEX(completion_entry);
- io_request = this_controller->io_request_table[index];
+ io_request = scic->io_request_table[index];
/* Make sure that we really want to process this IO request */
if (
&& (io_request->io_tag != SCI_CONTROLLER_INVALID_IO_TAG)
&& (
scic_sds_io_tag_get_sequence(io_request->io_tag)
- == this_controller->io_request_sequence[index]
+ == scic->io_request_sequence[index]
)
) {
/* Yep this is a valid io request pass it along to the io request handler */
/**
* This method processes an SDMA completion event. This is called from within
* the controller completion handler.
- * @this_controller:
+ * @scic:
* @completion_entry:
*
*/
static void scic_sds_controller_sdma_completion(
- struct scic_sds_controller *this_controller,
+ struct scic_sds_controller *scic,
u32 completion_entry)
{
u32 index;
switch (scu_get_command_request_type(completion_entry)) {
case SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC:
case SCU_CONTEXT_COMMAND_REQUEST_TYPE_DUMP_TC:
- io_request = this_controller->io_request_table[index];
- dev_warn(scic_to_dev(this_controller),
+ io_request = scic->io_request_table[index];
+ dev_warn(scic_to_dev(scic),
"%s: SCIC SDS Completion type SDMA %x for io request "
"%p\n",
__func__,
case SCU_CONTEXT_COMMAND_REQUEST_TYPE_DUMP_RNC:
case SCU_CONTEXT_COMMAND_REQUEST_TYPE_OTHER_RNC:
case SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_RNC:
- device = this_controller->device_table[index];
- dev_warn(scic_to_dev(this_controller),
+ device = scic->device_table[index];
+ dev_warn(scic_to_dev(scic),
"%s: SCIC SDS Completion type SDMA %x for remote "
"device %p\n",
__func__,
break;
default:
- dev_warn(scic_to_dev(this_controller),
+ dev_warn(scic_to_dev(scic),
"%s: SCIC SDS Completion unknown SDMA completion "
"type %x\n",
__func__,
/**
*
- * @this_controller:
+ * @scic:
* @completion_entry:
*
* This method processes an unsolicited frame message. This is called from
* within the controller completion handler. none
*/
static void scic_sds_controller_unsolicited_frame(
- struct scic_sds_controller *this_controller,
+ struct scic_sds_controller *scic,
u32 completion_entry)
{
u32 index;
frame_index = SCU_GET_FRAME_INDEX(completion_entry);
frame_header
- = this_controller->uf_control.buffers.array[frame_index].header;
- this_controller->uf_control.buffers.array[frame_index].state
+ = scic->uf_control.buffers.array[frame_index].header;
+ scic->uf_control.buffers.array[frame_index].state
= UNSOLICITED_FRAME_IN_USE;
if (SCU_GET_FRAME_ERROR(completion_entry)) {
* / @todo If the IAF frame or SIGNATURE FIS frame has an error will
* / this cause a problem? We expect the phy initialization will
* / fail if there is an error in the frame. */
- scic_sds_controller_release_frame(this_controller, frame_index);
+ scic_sds_controller_release_frame(scic, frame_index);
return;
}
if (frame_header->is_address_frame) {
index = SCU_GET_PROTOCOL_ENGINE_INDEX(completion_entry);
- phy = &this_controller->phy_table[index];
+ phy = &scic->phy_table[index];
if (phy != NULL) {
result = scic_sds_phy_frame_handler(phy, frame_index);
}
* device that has not yet been created. In either case forwared
* the frame to the PE and let it take care of the frame data. */
index = SCU_GET_PROTOCOL_ENGINE_INDEX(completion_entry);
- phy = &this_controller->phy_table[index];
+ phy = &scic->phy_table[index];
result = scic_sds_phy_frame_handler(phy, frame_index);
} else {
- if (index < this_controller->remote_node_entries)
- device = this_controller->device_table[index];
+ if (index < scic->remote_node_entries)
+ device = scic->device_table[index];
else
device = NULL;
if (device != NULL)
result = scic_sds_remote_device_frame_handler(device, frame_index);
else
- scic_sds_controller_release_frame(this_controller, frame_index);
+ scic_sds_controller_release_frame(scic, frame_index);
}
}
/**
* This method processes an event completion entry. This is called from within
* the controller completion handler.
- * @this_controller:
+ * @scic:
* @completion_entry:
*
*/
static void scic_sds_controller_event_completion(
- struct scic_sds_controller *this_controller,
+ struct scic_sds_controller *scic,
u32 completion_entry)
{
u32 index;
switch (scu_get_event_type(completion_entry)) {
case SCU_EVENT_TYPE_SMU_COMMAND_ERROR:
/* / @todo The driver did something wrong and we need to fix the condtion. */
- dev_err(scic_to_dev(this_controller),
+ dev_err(scic_to_dev(scic),
"%s: SCIC Controller 0x%p received SMU command error "
"0x%x\n",
__func__,
- this_controller,
+ scic,
completion_entry);
break;
/*
* / @todo This is a hardware failure and its likely that we want to
* / reset the controller. */
- dev_err(scic_to_dev(this_controller),
+ dev_err(scic_to_dev(scic),
"%s: SCIC Controller 0x%p received fatal controller "
"event 0x%x\n",
__func__,
- this_controller,
+ scic,
completion_entry);
break;
case SCU_EVENT_TYPE_TRANSPORT_ERROR:
- io_request = this_controller->io_request_table[index];
+ io_request = scic->io_request_table[index];
scic_sds_io_request_event_handler(io_request, completion_entry);
break;
switch (scu_get_event_specifier(completion_entry)) {
case SCU_EVENT_SPECIFIC_SMP_RESPONSE_NO_PE:
case SCU_EVENT_SPECIFIC_TASK_TIMEOUT:
- io_request = this_controller->io_request_table[index];
+ io_request = scic->io_request_table[index];
if (io_request != NULL)
scic_sds_io_request_event_handler(io_request, completion_entry);
else
- dev_warn(scic_to_dev(this_controller),
+ dev_warn(scic_to_dev(scic),
"%s: SCIC Controller 0x%p received "
"event 0x%x for io request object "
"that doesnt exist.\n",
__func__,
- this_controller,
+ scic,
completion_entry);
break;
case SCU_EVENT_SPECIFIC_IT_NEXUS_TIMEOUT:
- device = this_controller->device_table[index];
+ device = scic->device_table[index];
if (device != NULL)
scic_sds_remote_device_event_handler(device, completion_entry);
else
- dev_warn(scic_to_dev(this_controller),
+ dev_warn(scic_to_dev(scic),
"%s: SCIC Controller 0x%p received "
"event 0x%x for remote device object "
"that doesnt exist.\n",
__func__,
- this_controller,
+ scic,
completion_entry);
break;
* we get the event notification. This is a type 4 event. */
case SCU_EVENT_TYPE_OSSP_EVENT:
index = SCU_GET_PROTOCOL_ENGINE_INDEX(completion_entry);
- phy = &this_controller->phy_table[index];
+ phy = &scic->phy_table[index];
scic_sds_phy_event_handler(phy, completion_entry);
break;
case SCU_EVENT_TYPE_RNC_SUSPEND_TX:
case SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX:
case SCU_EVENT_TYPE_RNC_OPS_MISC:
- if (index < this_controller->remote_node_entries) {
- device = this_controller->device_table[index];
+ if (index < scic->remote_node_entries) {
+ device = scic->device_table[index];
if (device != NULL)
scic_sds_remote_device_event_handler(device, completion_entry);
} else
- dev_err(scic_to_dev(this_controller),
+ dev_err(scic_to_dev(scic),
"%s: SCIC Controller 0x%p received event 0x%x "
"for remote device object 0x%0x that doesnt "
"exist.\n",
__func__,
- this_controller,
+ scic,
completion_entry,
index);
break;
default:
- dev_warn(scic_to_dev(this_controller),
+ dev_warn(scic_to_dev(scic),
"%s: SCIC Controller received unknown event code %x\n",
__func__,
completion_entry);
/**
* This method is a private routine for processing the completion queue entries.
- * @this_controller:
+ * @scic:
*
*/
static void scic_sds_controller_process_completions(
- struct scic_sds_controller *this_controller)
+ struct scic_sds_controller *scic)
{
u32 completion_count = 0;
u32 completion_entry;
u32 event_index;
u32 event_cycle;
- dev_dbg(scic_to_dev(this_controller),
+ dev_dbg(scic_to_dev(scic),
"%s: completion queue begining get:0x%08x\n",
__func__,
- this_controller->completion_queue_get);
+ scic->completion_queue_get);
/* Get the component parts of the completion queue */
- get_index = NORMALIZE_GET_POINTER(this_controller->completion_queue_get);
- get_cycle = SMU_CQGR_CYCLE_BIT & this_controller->completion_queue_get;
+ get_index = NORMALIZE_GET_POINTER(scic->completion_queue_get);
+ get_cycle = SMU_CQGR_CYCLE_BIT & scic->completion_queue_get;
- event_index = NORMALIZE_EVENT_POINTER(this_controller->completion_queue_get);
- event_cycle = SMU_CQGR_EVENT_CYCLE_BIT & this_controller->completion_queue_get;
+ event_index = NORMALIZE_EVENT_POINTER(scic->completion_queue_get);
+ event_cycle = SMU_CQGR_EVENT_CYCLE_BIT & scic->completion_queue_get;
while (
NORMALIZE_GET_POINTER_CYCLE_BIT(get_cycle)
- == COMPLETION_QUEUE_CYCLE_BIT(this_controller->completion_queue[get_index])
+ == COMPLETION_QUEUE_CYCLE_BIT(scic->completion_queue[get_index])
) {
completion_count++;
- completion_entry = this_controller->completion_queue[get_index];
- INCREMENT_COMPLETION_QUEUE_GET(this_controller, get_index, get_cycle);
+ completion_entry = scic->completion_queue[get_index];
+ INCREMENT_COMPLETION_QUEUE_GET(scic, get_index, get_cycle);
- dev_dbg(scic_to_dev(this_controller),
+ dev_dbg(scic_to_dev(scic),
"%s: completion queue entry:0x%08x\n",
__func__,
completion_entry);
switch (SCU_GET_COMPLETION_TYPE(completion_entry)) {
case SCU_COMPLETION_TYPE_TASK:
- scic_sds_controller_task_completion(this_controller, completion_entry);
+ scic_sds_controller_task_completion(scic, completion_entry);
break;
case SCU_COMPLETION_TYPE_SDMA:
- scic_sds_controller_sdma_completion(this_controller, completion_entry);
+ scic_sds_controller_sdma_completion(scic, completion_entry);
break;
case SCU_COMPLETION_TYPE_UFI:
- scic_sds_controller_unsolicited_frame(this_controller, completion_entry);
+ scic_sds_controller_unsolicited_frame(scic, completion_entry);
break;
case SCU_COMPLETION_TYPE_EVENT:
- INCREMENT_EVENT_QUEUE_GET(this_controller, event_index, event_cycle);
- scic_sds_controller_event_completion(this_controller, completion_entry);
+ INCREMENT_EVENT_QUEUE_GET(scic, event_index, event_cycle);
+ scic_sds_controller_event_completion(scic, completion_entry);
break;
case SCU_COMPLETION_TYPE_NOTIFY:
/*
* Presently we do the same thing with a notify event that we do with the
* other event codes. */
- INCREMENT_EVENT_QUEUE_GET(this_controller, event_index, event_cycle);
- scic_sds_controller_event_completion(this_controller, completion_entry);
+ INCREMENT_EVENT_QUEUE_GET(scic, event_index, event_cycle);
+ scic_sds_controller_event_completion(scic, completion_entry);
break;
default:
- dev_warn(scic_to_dev(this_controller),
+ dev_warn(scic_to_dev(scic),
"%s: SCIC Controller received unknown "
"completion type %x\n",
__func__,
/* Update the get register if we completed one or more entries */
if (completion_count > 0) {
- this_controller->completion_queue_get =
- SMU_CQGR_GEN_BIT(ENABLE)
- | SMU_CQGR_GEN_BIT(EVENT_ENABLE)
- | event_cycle | SMU_CQGR_GEN_VAL(EVENT_POINTER, event_index)
- | get_cycle | SMU_CQGR_GEN_VAL(POINTER, get_index);
+ scic->completion_queue_get =
+ SMU_CQGR_GEN_BIT(ENABLE) |
+ SMU_CQGR_GEN_BIT(EVENT_ENABLE) |
+ event_cycle |
+ SMU_CQGR_GEN_VAL(EVENT_POINTER, event_index) |
+ get_cycle |
+ SMU_CQGR_GEN_VAL(POINTER, get_index);
- writel(this_controller->completion_queue_get,
- &this_controller->smu_registers->completion_queue_get);
+ writel(scic->completion_queue_get,
+ &scic->smu_registers->completion_queue_get);
}
- dev_dbg(scic_to_dev(this_controller),
+ dev_dbg(scic_to_dev(scic),
"%s: completion queue ending get:0x%08x\n",
__func__,
- this_controller->completion_queue_get);
+ scic->completion_queue_get);
}
/**
* This method will write to the SCU PCP register the request value. The method
* is used to suspend/resume ports, devices, and phys.
- * @this_controller:
+ * @scic:
*
*
*/
void scic_sds_controller_post_request(
- struct scic_sds_controller *this_controller,
+ struct scic_sds_controller *scic,
u32 request)
{
- dev_dbg(scic_to_dev(this_controller),
+ dev_dbg(scic_to_dev(scic),
"%s: SCIC Controller 0x%p post request 0x%08x\n",
__func__,
- this_controller,
+ scic,
request);
- writel(request, &this_controller->smu_registers->post_context_port);
+ writel(request, &scic->smu_registers->post_context_port);
}
/**
* This method will copy the soft copy of the task context into the physical
* memory accessible by the controller.
- * @this_controller: This parameter specifies the controller for which to copy
+ * @scic: This parameter specifies the controller for which to copy
* the task context.
- * @this_request: This parameter specifies the request for which the task
+ * @sci_req: This parameter specifies the request for which the task
* context is being copied.
*
* After this call is made the SCIC_SDS_IO_REQUEST object will always point to
* memory). none
*/
void scic_sds_controller_copy_task_context(
- struct scic_sds_controller *this_controller,
- struct scic_sds_request *this_request)
+ struct scic_sds_controller *scic,
+ struct scic_sds_request *sci_req)
{
struct scu_task_context *task_context_buffer;
task_context_buffer = scic_sds_controller_get_task_context_buffer(
- this_controller, this_request->io_tag
- );
+ scic, sci_req->io_tag);
- memcpy(
- task_context_buffer,
- this_request->task_context_buffer,
- SCI_FIELD_OFFSET(struct scu_task_context, sgl_snapshot_ac)
- );
+ memcpy(task_context_buffer,
+ sci_req->task_context_buffer,
+ SCI_FIELD_OFFSET(struct scu_task_context, sgl_snapshot_ac));
/*
* Now that the soft copy of the TC has been copied into the TC
* table accessible by the silicon. Thus, any further changes to
* the TC (e.g. TC termination) occur in the appropriate location. */
- this_request->task_context_buffer = task_context_buffer;
+ sci_req->task_context_buffer = task_context_buffer;
}
/**
* This method returns the task context buffer for the given io tag.
- * @this_controller:
+ * @scic:
* @io_tag:
*
* struct scu_task_context*
*/
struct scu_task_context *scic_sds_controller_get_task_context_buffer(
- struct scic_sds_controller *this_controller,
+ struct scic_sds_controller *scic,
u16 io_tag
) {
u16 task_index = scic_sds_io_tag_get_index(io_tag);
- if (task_index < this_controller->task_context_entries) {
- return &this_controller->task_context_table[task_index];
+ if (task_index < scic->task_context_entries) {
+ return &scic->task_context_table[task_index];
}
return NULL;
/**
* This method returnst the sequence value from the io tag value
- * @this_controller:
+ * @scic:
* @io_tag:
*
* u16
/**
* This method returns the IO request associated with the tag value
- * @this_controller:
+ * @scic:
* @io_tag:
*
* SCIC_SDS_IO_REQUEST_T* NULL if there is no valid IO request at the tag value
*/
struct scic_sds_request *scic_sds_controller_get_io_request_from_tag(
- struct scic_sds_controller *this_controller,
+ struct scic_sds_controller *scic,
u16 io_tag
) {
u16 task_index;
task_index = scic_sds_io_tag_get_index(io_tag);
- if (task_index < this_controller->task_context_entries) {
- if (this_controller->io_request_table[task_index] != NULL) {
+ if (task_index < scic->task_context_entries) {
+ if (scic->io_request_table[task_index] != NULL) {
task_sequence = scic_sds_io_tag_get_sequence(io_tag);
- if (task_sequence == this_controller->io_request_sequence[task_index]) {
- return this_controller->io_request_table[task_index];
+ if (task_sequence == scic->io_request_sequence[task_index]) {
+ return scic->io_request_table[task_index];
}
}
}
* This method allocates remote node index and the reserves the remote node
* context space for use. This method can fail if there are no more remote
* node index available.
- * @this_controller: This is the controller object which contains the set of
+ * @scic: This is the controller object which contains the set of
* free remote node ids
- * @the_devce: This is the device object which is requesting the a remote node
+ * @sci_dev: This is the device object which is requesting the a remote node
* id
* @node_id: This is the remote node id that is assinged to the device if one
* is available
* node index available.
*/
enum sci_status scic_sds_controller_allocate_remote_node_context(
- struct scic_sds_controller *this_controller,
- struct scic_sds_remote_device *the_device,
+ struct scic_sds_controller *scic,
+ struct scic_sds_remote_device *sci_dev,
u16 *node_id)
{
u16 node_index;
- u32 remote_node_count = scic_sds_remote_device_node_count(the_device);
+ u32 remote_node_count = scic_sds_remote_device_node_count(sci_dev);
node_index = scic_sds_remote_node_table_allocate_remote_node(
- &this_controller->available_remote_nodes, remote_node_count
+ &scic->available_remote_nodes, remote_node_count
);
if (node_index != SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX) {
- this_controller->device_table[node_index] = the_device;
+ scic->device_table[node_index] = sci_dev;
*node_id = node_index;
* This method frees the remote node index back to the available pool. Once
* this is done the remote node context buffer is no longer valid and can
* not be used.
- * @this_controller:
- * @the_device:
+ * @scic:
+ * @sci_dev:
* @node_id:
*
*/
void scic_sds_controller_free_remote_node_context(
- struct scic_sds_controller *this_controller,
- struct scic_sds_remote_device *the_device,
+ struct scic_sds_controller *scic,
+ struct scic_sds_remote_device *sci_dev,
u16 node_id)
{
- u32 remote_node_count = scic_sds_remote_device_node_count(the_device);
+ u32 remote_node_count = scic_sds_remote_device_node_count(sci_dev);
- if (this_controller->device_table[node_id] == the_device) {
- this_controller->device_table[node_id] = NULL;
+ if (scic->device_table[node_id] == sci_dev) {
+ scic->device_table[node_id] = NULL;
scic_sds_remote_node_table_release_remote_node_index(
- &this_controller->available_remote_nodes, remote_node_count, node_id
+ &scic->available_remote_nodes, remote_node_count, node_id
);
}
}
/**
* This method returns the union scu_remote_node_context for the specified remote
* node id.
- * @this_controller:
+ * @scic:
* @node_id:
*
* union scu_remote_node_context*
*/
union scu_remote_node_context *scic_sds_controller_get_remote_node_context_buffer(
- struct scic_sds_controller *this_controller,
+ struct scic_sds_controller *scic,
u16 node_id
) {
if (
- (node_id < this_controller->remote_node_entries)
- && (this_controller->device_table[node_id] != NULL)
+ (node_id < scic->remote_node_entries)
+ && (scic->device_table[node_id] != NULL)
) {
- return &this_controller->remote_node_context_table[node_id];
+ return &scic->remote_node_context_table[node_id];
}
return NULL;
* re-use by the hardware. The data contained in the frame header and frame
* buffer is no longer valid. The UF queue get pointer is only updated if UF
* control indicates this is appropriate.
- * @this_controller:
+ * @scic:
* @frame_index:
*
*/
void scic_sds_controller_release_frame(
- struct scic_sds_controller *this_controller,
+ struct scic_sds_controller *scic,
u32 frame_index)
{
if (scic_sds_unsolicited_frame_control_release_frame(
- &this_controller->uf_control, frame_index) == true)
- writel(this_controller->uf_control.get,
- &this_controller->scu_registers->sdma.unsolicited_frame_get_pointer);
+ &scic->uf_control, frame_index) == true)
+ writel(scic->uf_control.get,
+ &scic->scu_registers->sdma.unsolicited_frame_get_pointer);
}
/**
static void scic_sds_controller_initial_state_enter(
struct sci_base_object *object)
{
- struct scic_sds_controller *this_controller;
+ struct scic_sds_controller *scic;
- this_controller = (struct scic_sds_controller *)object;
+ scic = (struct scic_sds_controller *)object;
- sci_base_state_machine_change_state(&this_controller->state_machine,
+ sci_base_state_machine_change_state(&scic->state_machine,
SCI_BASE_CONTROLLER_STATE_RESET);
}
static void scic_sds_controller_ready_state_enter(
struct sci_base_object *object)
{
- struct scic_sds_controller *this_controller;
+ struct scic_sds_controller *scic;
- this_controller = (struct scic_sds_controller *)object;
+ scic = (struct scic_sds_controller *)object;
/* set the default interrupt coalescence number and timeout value. */
scic_controller_set_interrupt_coalescence(
- this_controller, 0x10, 250);
+ scic, 0x10, 250);
}
/**
static void scic_sds_controller_ready_state_exit(
struct sci_base_object *object)
{
- struct scic_sds_controller *this_controller;
+ struct scic_sds_controller *scic;
- this_controller = (struct scic_sds_controller *)object;
+ scic = (struct scic_sds_controller *)object;
/* disable interrupt coalescence. */
- scic_controller_set_interrupt_coalescence(this_controller, 0, 0);
+ scic_controller_set_interrupt_coalescence(scic, 0, 0);
}
/**
static void scic_sds_controller_stopping_state_enter(
struct sci_base_object *object)
{
- struct scic_sds_controller *this_controller;
+ struct scic_sds_controller *scic;
- this_controller = (struct scic_sds_controller *)object;
+ scic = (struct scic_sds_controller *)object;
/* Stop all of the components for this controller */
- scic_sds_controller_stop_phys(this_controller);
- scic_sds_controller_stop_ports(this_controller);
- scic_sds_controller_stop_devices(this_controller);
+ scic_sds_controller_stop_phys(scic);
+ scic_sds_controller_stop_ports(scic);
+ scic_sds_controller_stop_devices(scic);
}
/**
enum sci_status scic_sds_controller_allocate_remote_node_context(
struct scic_sds_controller *this_controller,
- struct scic_sds_remote_device *the_device,
+ struct scic_sds_remote_device *sci_dev,
u16 *node_id);
void scic_sds_controller_free_remote_node_context(
struct scic_sds_controller *this_controller,
- struct scic_sds_remote_device *the_device,
+ struct scic_sds_remote_device *sci_dev,
u16 node_id);
union scu_remote_node_context *scic_sds_controller_get_remote_node_context_buffer(
void scic_sds_controller_power_control_queue_insert(
struct scic_sds_controller *this_controller,
- struct scic_sds_phy *the_phy);
+ struct scic_sds_phy *sci_phy);
void scic_sds_controller_power_control_queue_remove(
struct scic_sds_controller *this_controller,
- struct scic_sds_phy *the_phy);
+ struct scic_sds_phy *sci_phy);
void scic_sds_controller_link_up(
struct scic_sds_controller *this_controller,
- struct scic_sds_port *the_port,
- struct scic_sds_phy *the_phy);
+ struct scic_sds_port *sci_port,
+ struct scic_sds_phy *sci_phy);
void scic_sds_controller_link_down(
struct scic_sds_controller *this_controller,
- struct scic_sds_port *the_port,
- struct scic_sds_phy *the_phy);
+ struct scic_sds_port *sci_port,
+ struct scic_sds_phy *sci_phy);
void scic_sds_controller_remote_device_stopped(
struct scic_sds_controller *this_controller,
- struct scic_sds_remote_device *the_device);
+ struct scic_sds_remote_device *sci_dev);
void scic_sds_controller_copy_task_context(
struct scic_sds_controller *this_controller,
/**
* This method will initialize the phy transport layer registers
- * @this_phy:
+ * @sci_phy:
* @transport_layer_registers
*
* enum sci_status
*/
static enum sci_status scic_sds_phy_transport_layer_initialization(
- struct scic_sds_phy *this_phy,
+ struct scic_sds_phy *sci_phy,
struct scu_transport_layer_registers __iomem *transport_layer_registers)
{
u32 tl_control;
- this_phy->transport_layer_registers = transport_layer_registers;
+ sci_phy->transport_layer_registers = transport_layer_registers;
writel(SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX,
- &this_phy->transport_layer_registers->stp_rni);
+ &sci_phy->transport_layer_registers->stp_rni);
- /* Hardware team recommends that we enable the STP prefetch for all transports */
- tl_control = readl(&this_phy->transport_layer_registers->control);
+ /*
+ * Hardware team recommends that we enable the STP prefetch for all
+ * transports
+ */
+ tl_control = readl(&sci_phy->transport_layer_registers->control);
tl_control |= SCU_TLCR_GEN_BIT(STP_WRITE_DATA_PREFETCH);
- writel(tl_control, &this_phy->transport_layer_registers->control);
+ writel(tl_control, &sci_phy->transport_layer_registers->control);
return SCI_SUCCESS;
}
* This method returns the port currently containing this phy. If the phy is
* currently contained by the dummy port, then the phy is considered to not
* be part of a port.
- * @this_phy: This parameter specifies the phy for which to retrieve the
+ * @sci_phy: This parameter specifies the phy for which to retrieve the
* containing port.
*
* This method returns a handle to a port that contains the supplied phy.
* values indicate a handle/pointer to the port containing the phy.
*/
struct scic_sds_port *scic_sds_phy_get_port(
- struct scic_sds_phy *this_phy)
+ struct scic_sds_phy *sci_phy)
{
- if (scic_sds_port_get_index(this_phy->owning_port) == SCIC_SDS_DUMMY_PORT)
+ if (scic_sds_port_get_index(sci_phy->owning_port) == SCIC_SDS_DUMMY_PORT)
return NULL;
- return this_phy->owning_port;
+ return sci_phy->owning_port;
}
/**
* This method will assign a port to the phy object.
- * @out]: this_phy This parameter specifies the phy for which to assign a port
+ * @out]: sci_phy This parameter specifies the phy for which to assign a port
* object.
*
*
*/
void scic_sds_phy_set_port(
- struct scic_sds_phy *this_phy,
- struct scic_sds_port *the_port)
+ struct scic_sds_phy *sci_phy,
+ struct scic_sds_port *sci_port)
{
- this_phy->owning_port = the_port;
+ sci_phy->owning_port = sci_port;
- if (this_phy->bcn_received_while_port_unassigned) {
- this_phy->bcn_received_while_port_unassigned = false;
- scic_sds_port_broadcast_change_received(this_phy->owning_port, this_phy);
+ if (sci_phy->bcn_received_while_port_unassigned) {
+ sci_phy->bcn_received_while_port_unassigned = false;
+ scic_sds_port_broadcast_change_received(sci_phy->owning_port, sci_phy);
}
}
/**
* This method assigns the direct attached device ID for this phy.
*
- * @this_phy The phy for which the direct attached device id is to
+ * @sci_phy The phy for which the direct attached device id is to
* be assigned.
* @device_id The direct attached device ID to assign to the phy.
* This will either be the RNi for the device or an invalid RNi if there
* is no current device assigned to the phy.
*/
void scic_sds_phy_setup_transport(
- struct scic_sds_phy *this_phy,
+ struct scic_sds_phy *sci_phy,
u32 device_id)
{
u32 tl_control;
- writel(device_id, &this_phy->transport_layer_registers->stp_rni);
+ writel(device_id, &sci_phy->transport_layer_registers->stp_rni);
/*
* The read should guarantee that the first write gets posted
* before the next write
*/
- tl_control = readl(&this_phy->transport_layer_registers->control);
+ tl_control = readl(&sci_phy->transport_layer_registers->control);
tl_control |= SCU_TLCR_GEN_BIT(CLEAR_TCI_NCQ_MAPPING_TABLE);
- writel(tl_control, &this_phy->transport_layer_registers->control);
+ writel(tl_control, &sci_phy->transport_layer_registers->control);
}
/**
*
- * @this_phy: The phy object to be suspended.
+ * @sci_phy: The phy object to be suspended.
*
* This function will perform the register reads/writes to suspend the SCU
* hardware protocol engine. none
*/
static void scic_sds_phy_suspend(
- struct scic_sds_phy *this_phy)
+ struct scic_sds_phy *sci_phy)
{
u32 scu_sas_pcfg_value;
scu_sas_pcfg_value =
- readl(&this_phy->link_layer_registers->phy_configuration);
+ readl(&sci_phy->link_layer_registers->phy_configuration);
scu_sas_pcfg_value |= SCU_SAS_PCFG_GEN_BIT(SUSPEND_PROTOCOL_ENGINE);
writel(scu_sas_pcfg_value,
- &this_phy->link_layer_registers->phy_configuration);
+ &sci_phy->link_layer_registers->phy_configuration);
- scic_sds_phy_setup_transport(this_phy, SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX);
+ scic_sds_phy_setup_transport(
+ sci_phy,
+ SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX);
}
/**
*
- * @this_phy: The phy object to resume.
+ * @sci_phy: The phy object to resume.
*
* This function will perform the register reads/writes required to resume the
* SCU hardware protocol engine. none
*/
void scic_sds_phy_resume(
- struct scic_sds_phy *this_phy)
+ struct scic_sds_phy *sci_phy)
{
u32 scu_sas_pcfg_value;
scu_sas_pcfg_value =
- readl(&this_phy->link_layer_registers->phy_configuration);
+ readl(&sci_phy->link_layer_registers->phy_configuration);
scu_sas_pcfg_value &= ~SCU_SAS_PCFG_GEN_BIT(SUSPEND_PROTOCOL_ENGINE);
writel(scu_sas_pcfg_value,
- &this_phy->link_layer_registers->phy_configuration);
+ &sci_phy->link_layer_registers->phy_configuration);
}
/**
* This method returns the local sas address assigned to this phy.
- * @this_phy: This parameter specifies the phy for which to retrieve the local
+ * @sci_phy: This parameter specifies the phy for which to retrieve the local
* SAS address.
* @sas_address: This parameter specifies the location into which to copy the
* local SAS address.
*
*/
void scic_sds_phy_get_sas_address(
- struct scic_sds_phy *this_phy,
+ struct scic_sds_phy *sci_phy,
struct sci_sas_address *sas_address)
{
- sas_address->high = readl(&this_phy->link_layer_registers->source_sas_address_high);
- sas_address->low = readl(&this_phy->link_layer_registers->source_sas_address_low);
+ sas_address->high = readl(&sci_phy->link_layer_registers->source_sas_address_high);
+ sas_address->low = readl(&sci_phy->link_layer_registers->source_sas_address_low);
}
/**
* This method returns the remote end-point (i.e. attached) sas address
* assigned to this phy.
- * @this_phy: This parameter specifies the phy for which to retrieve the remote
+ * @sci_phy: This parameter specifies the phy for which to retrieve the remote
* end-point SAS address.
* @sas_address: This parameter specifies the location into which to copy the
* remote end-point SAS address.
*
*/
void scic_sds_phy_get_attached_sas_address(
- struct scic_sds_phy *this_phy,
+ struct scic_sds_phy *sci_phy,
struct sci_sas_address *sas_address)
{
sas_address->high
- = this_phy->phy_type.sas.identify_address_frame_buffer.sas_address.high;
+ = sci_phy->phy_type.sas.identify_address_frame_buffer.sas_address.high;
sas_address->low
- = this_phy->phy_type.sas.identify_address_frame_buffer.sas_address.low;
+ = sci_phy->phy_type.sas.identify_address_frame_buffer.sas_address.low;
}
/**
* This method returns the supported protocols assigned to this phy
- * @this_phy:
+ * @sci_phy:
*
*
*/
void scic_sds_phy_get_protocols(
- struct scic_sds_phy *this_phy,
+ struct scic_sds_phy *sci_phy,
struct sci_sas_identify_address_frame_protocols *protocols)
{
protocols->u.all =
- (u16)(readl(&this_phy->
+ (u16)(readl(&sci_phy->
link_layer_registers->transmit_identification) &
0x0000FFFF);
}
/**
*
- * @this_phy: The parameter is the phy object for which the attached phy
+ * @sci_phy: The parameter is the phy object for which the attached phy
* protcols are to be returned.
*
* This method returns the supported protocols for the attached phy. If this
* value.
*/
void scic_sds_phy_get_attached_phy_protocols(
- struct scic_sds_phy *this_phy,
+ struct scic_sds_phy *sci_phy,
struct sci_sas_identify_address_frame_protocols *protocols)
{
protocols->u.all = 0;
- if (this_phy->protocol == SCIC_SDS_PHY_PROTOCOL_SAS) {
+ if (sci_phy->protocol == SCIC_SDS_PHY_PROTOCOL_SAS) {
protocols->u.all =
- this_phy->phy_type.sas.identify_address_frame_buffer.protocols.u.all;
- } else if (this_phy->protocol == SCIC_SDS_PHY_PROTOCOL_SATA) {
+ sci_phy->phy_type.sas.identify_address_frame_buffer.protocols.u.all;
+ } else if (sci_phy->protocol == SCIC_SDS_PHY_PROTOCOL_SATA) {
protocols->u.bits.stp_target = 1;
}
}
/**
* This method will attempt to reset the phy. This request is only valid when
* the phy is in an ready state
- * @this_phy:
+ * @sci_phy:
*
* enum sci_status
*/
enum sci_status scic_sds_phy_reset(
- struct scic_sds_phy *this_phy)
+ struct scic_sds_phy *sci_phy)
{
- return this_phy->state_handlers->reset_handler(this_phy);
+ return sci_phy->state_handlers->reset_handler(sci_phy);
}
/**
* This method will process the event code received.
- * @this_phy:
+ * @sci_phy:
* @event_code:
*
* enum sci_status
*/
enum sci_status scic_sds_phy_event_handler(
- struct scic_sds_phy *this_phy,
+ struct scic_sds_phy *sci_phy,
u32 event_code)
{
- return this_phy->state_handlers->event_handler(this_phy, event_code);
+ return sci_phy->state_handlers->event_handler(sci_phy, event_code);
}
/**
* This method will process the frame index received.
- * @this_phy:
+ * @sci_phy:
* @frame_index:
*
* enum sci_status
*/
enum sci_status scic_sds_phy_frame_handler(
- struct scic_sds_phy *this_phy,
+ struct scic_sds_phy *sci_phy,
u32 frame_index)
{
- return this_phy->state_handlers->frame_handler(this_phy, frame_index);
+ return sci_phy->state_handlers->frame_handler(sci_phy, frame_index);
}
/**
* This method will give the phy permission to consume power
- * @this_phy:
+ * @sci_phy:
*
* enum sci_status
*/
enum sci_status scic_sds_phy_consume_power_handler(
- struct scic_sds_phy *this_phy)
+ struct scic_sds_phy *sci_phy)
{
- return this_phy->state_handlers->consume_power_handler(this_phy);
+ return sci_phy->state_handlers->consume_power_handler(sci_phy);
}
/*
/**
*
- * @this_phy: The phy object that received SAS PHY DETECTED.
+ * @sci_phy: The phy object that received SAS PHY DETECTED.
*
* This method continues the link training for the phy as if it were a SAS PHY
* instead of a SATA PHY. This is done because the completion queue had a SAS
* none
*/
static void scic_sds_phy_start_sas_link_training(
- struct scic_sds_phy *this_phy)
+ struct scic_sds_phy *sci_phy)
{
u32 phy_control;
phy_control =
- readl(&this_phy->link_layer_registers->phy_configuration);
+ readl(&sci_phy->link_layer_registers->phy_configuration);
phy_control |= SCU_SAS_PCFG_GEN_BIT(SATA_SPINUP_HOLD);
writel(phy_control,
- &this_phy->link_layer_registers->phy_configuration);
+ &sci_phy->link_layer_registers->phy_configuration);
sci_base_state_machine_change_state(
- &this_phy->starting_substate_machine,
+ &sci_phy->starting_substate_machine,
SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SAS_SPEED_EN
);
- this_phy->protocol = SCIC_SDS_PHY_PROTOCOL_SAS;
+ sci_phy->protocol = SCIC_SDS_PHY_PROTOCOL_SAS;
}
/**
*
- * @this_phy: The phy object that received a SATA SPINUP HOLD event
+ * @sci_phy: The phy object that received a SATA SPINUP HOLD event
*
* This method continues the link training for the phy as if it were a SATA PHY
* instead of a SAS PHY. This is done because the completion queue had a SATA
* SPINUP HOLD event when the state machine was expecting a SAS PHY event. none
*/
static void scic_sds_phy_start_sata_link_training(
- struct scic_sds_phy *this_phy)
+ struct scic_sds_phy *sci_phy)
{
sci_base_state_machine_change_state(
- &this_phy->starting_substate_machine,
+ &sci_phy->starting_substate_machine,
SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SATA_POWER
);
- this_phy->protocol = SCIC_SDS_PHY_PROTOCOL_SATA;
+ sci_phy->protocol = SCIC_SDS_PHY_PROTOCOL_SATA;
}
/**
* SCI_FAILURE on any unexpected event notifation
*/
static enum sci_status scic_sds_phy_starting_substate_await_ossp_event_handler(
- struct scic_sds_phy *this_phy,
+ struct scic_sds_phy *sci_phy,
u32 event_code)
{
u32 result = SCI_SUCCESS;
switch (scu_get_event_code(event_code)) {
case SCU_EVENT_SAS_PHY_DETECTED:
- scic_sds_phy_start_sas_link_training(this_phy);
- this_phy->is_in_link_training = true;
+ scic_sds_phy_start_sas_link_training(sci_phy);
+ sci_phy->is_in_link_training = true;
break;
case SCU_EVENT_SATA_SPINUP_HOLD:
- scic_sds_phy_start_sata_link_training(this_phy);
- this_phy->is_in_link_training = true;
+ scic_sds_phy_start_sata_link_training(sci_phy);
+ sci_phy->is_in_link_training = true;
break;
default:
- dev_dbg(sciphy_to_dev(this_phy),
+ dev_dbg(sciphy_to_dev(sci_phy),
"%s: PHY starting substate machine received "
"unexpected event_code %x\n",
__func__,
* event notification SCI_FAILURE on any unexpected event notifation
*/
static enum sci_status scic_sds_phy_starting_substate_await_sas_phy_speed_event_handler(
- struct scic_sds_phy *this_phy,
+ struct scic_sds_phy *sci_phy,
u32 event_code)
{
u32 result = SCI_SUCCESS;
case SCU_EVENT_SAS_15:
case SCU_EVENT_SAS_15_SSC:
scic_sds_phy_complete_link_training(
- this_phy, SAS_LINK_RATE_1_5_GBPS, SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_IAF_UF
- );
+ sci_phy,
+ SAS_LINK_RATE_1_5_GBPS,
+ SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_IAF_UF);
break;
case SCU_EVENT_SAS_30:
case SCU_EVENT_SAS_30_SSC:
scic_sds_phy_complete_link_training(
- this_phy, SAS_LINK_RATE_3_0_GBPS, SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_IAF_UF
- );
+ sci_phy,
+ SAS_LINK_RATE_3_0_GBPS,
+ SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_IAF_UF);
break;
case SCU_EVENT_SAS_60:
case SCU_EVENT_SAS_60_SSC:
scic_sds_phy_complete_link_training(
- this_phy, SAS_LINK_RATE_6_0_GBPS, SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_IAF_UF
- );
+ sci_phy,
+ SAS_LINK_RATE_6_0_GBPS,
+ SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_IAF_UF);
break;
case SCU_EVENT_SATA_SPINUP_HOLD:
/*
* We were doing SAS PHY link training and received a SATA PHY event
* continue OOB/SN as if this were a SATA PHY */
- scic_sds_phy_start_sata_link_training(this_phy);
+ scic_sds_phy_start_sata_link_training(sci_phy);
break;
case SCU_EVENT_LINK_FAILURE:
/* Link failure change state back to the starting state */
- scic_sds_phy_restart_starting_state(this_phy);
+ scic_sds_phy_restart_starting_state(sci_phy);
break;
default:
- dev_warn(sciphy_to_dev(this_phy),
+ dev_warn(sciphy_to_dev(sci_phy),
"%s: PHY starting substate machine received "
"unexpected event_code %x\n",
__func__,
* unexpected event notifation
*/
static enum sci_status scic_sds_phy_starting_substate_await_iaf_uf_event_handler(
- struct scic_sds_phy *this_phy,
+ struct scic_sds_phy *sci_phy,
u32 event_code)
{
u32 result = SCI_SUCCESS;
switch (scu_get_event_code(event_code)) {
case SCU_EVENT_SAS_PHY_DETECTED:
/* Backup the state machine */
- scic_sds_phy_start_sas_link_training(this_phy);
+ scic_sds_phy_start_sas_link_training(sci_phy);
break;
case SCU_EVENT_SATA_SPINUP_HOLD:
/*
* We were doing SAS PHY link training and received a SATA PHY event
* continue OOB/SN as if this were a SATA PHY */
- scic_sds_phy_start_sata_link_training(this_phy);
+ scic_sds_phy_start_sata_link_training(sci_phy);
break;
case SCU_EVENT_RECEIVED_IDENTIFY_TIMEOUT:
case SCU_EVENT_LINK_FAILURE:
case SCU_EVENT_HARD_RESET_RECEIVED:
/* Start the oob/sn state machine over again */
- scic_sds_phy_restart_starting_state(this_phy);
+ scic_sds_phy_restart_starting_state(sci_phy);
break;
default:
- dev_warn(sciphy_to_dev(this_phy),
+ dev_warn(sciphy_to_dev(sci_phy),
"%s: PHY starting substate machine received "
"unexpected event_code %x\n",
__func__,
* notifation
*/
static enum sci_status scic_sds_phy_starting_substate_await_sas_power_event_handler(
- struct scic_sds_phy *this_phy,
+ struct scic_sds_phy *sci_phy,
u32 event_code)
{
u32 result = SCI_SUCCESS;
switch (scu_get_event_code(event_code)) {
case SCU_EVENT_LINK_FAILURE:
/* Link failure change state back to the starting state */
- scic_sds_phy_restart_starting_state(this_phy);
+ scic_sds_phy_restart_starting_state(sci_phy);
break;
default:
- dev_warn(sciphy_to_dev(this_phy),
+ dev_warn(sciphy_to_dev(sci_phy),
"%s: PHY starting substate machine received unexpected "
"event_code %x\n",
__func__,
* on a link failure event SCI_FAILURE on any unexpected event notifation
*/
static enum sci_status scic_sds_phy_starting_substate_await_sata_power_event_handler(
- struct scic_sds_phy *this_phy,
+ struct scic_sds_phy *sci_phy,
u32 event_code)
{
u32 result = SCI_SUCCESS;
switch (scu_get_event_code(event_code)) {
case SCU_EVENT_LINK_FAILURE:
/* Link failure change state back to the starting state */
- scic_sds_phy_restart_starting_state(this_phy);
+ scic_sds_phy_restart_starting_state(sci_phy);
break;
case SCU_EVENT_SATA_SPINUP_HOLD:
/*
* There has been a change in the phy type before OOB/SN for the
* SATA finished start down the SAS link traning path. */
- scic_sds_phy_start_sas_link_training(this_phy);
+ scic_sds_phy_start_sas_link_training(sci_phy);
break;
default:
- dev_warn(sciphy_to_dev(this_phy),
+ dev_warn(sciphy_to_dev(sci_phy),
"%s: PHY starting substate machine received "
"unexpected event_code %x\n",
__func__,
* valid event notification SCI_FAILURE on any unexpected event notifation
*/
static enum sci_status scic_sds_phy_starting_substate_await_sata_speed_event_handler(
- struct scic_sds_phy *this_phy,
+ struct scic_sds_phy *sci_phy,
u32 event_code)
{
u32 result = SCI_SUCCESS;
case SCU_EVENT_SATA_15:
case SCU_EVENT_SATA_15_SSC:
scic_sds_phy_complete_link_training(
- this_phy,
+ sci_phy,
SAS_LINK_RATE_1_5_GBPS,
- SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SIG_FIS_UF
- );
+ SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SIG_FIS_UF);
break;
case SCU_EVENT_SATA_30:
case SCU_EVENT_SATA_30_SSC:
scic_sds_phy_complete_link_training(
- this_phy,
+ sci_phy,
SAS_LINK_RATE_3_0_GBPS,
- SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SIG_FIS_UF
- );
+ SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SIG_FIS_UF);
break;
case SCU_EVENT_SATA_60:
case SCU_EVENT_SATA_60_SSC:
scic_sds_phy_complete_link_training(
- this_phy,
+ sci_phy,
SAS_LINK_RATE_6_0_GBPS,
- SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SIG_FIS_UF
- );
+ SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SIG_FIS_UF);
break;
case SCU_EVENT_LINK_FAILURE:
/* Link failure change state back to the starting state */
- scic_sds_phy_restart_starting_state(this_phy);
+ scic_sds_phy_restart_starting_state(sci_phy);
break;
case SCU_EVENT_SAS_PHY_DETECTED:
/*
* There has been a change in the phy type before OOB/SN for the
* SATA finished start down the SAS link traning path. */
- scic_sds_phy_start_sas_link_training(this_phy);
+ scic_sds_phy_start_sas_link_training(sci_phy);
break;
default:
- dev_warn(sciphy_to_dev(this_phy),
+ dev_warn(sciphy_to_dev(sci_phy),
"%s: PHY starting substate machine received "
"unexpected event_code %x\n",
__func__,
static void scic_sds_phy_starting_await_ossp_en_substate_enter(
struct sci_base_object *object)
{
- struct scic_sds_phy *this_phy;
+ struct scic_sds_phy *sci_phy;
- this_phy = (struct scic_sds_phy *)object;
+ sci_phy = (struct scic_sds_phy *)object;
scic_sds_phy_set_starting_substate_handlers(
- this_phy, SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_OSSP_EN
+ sci_phy, SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_OSSP_EN
);
}
static void scic_sds_phy_starting_await_sas_speed_en_substate_enter(
struct sci_base_object *object)
{
- struct scic_sds_phy *this_phy;
+ struct scic_sds_phy *sci_phy;
- this_phy = (struct scic_sds_phy *)object;
+ sci_phy = (struct scic_sds_phy *)object;
scic_sds_phy_set_starting_substate_handlers(
- this_phy, SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SAS_SPEED_EN
+ sci_phy, SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SAS_SPEED_EN
);
}
static void scic_sds_phy_starting_await_iaf_uf_substate_enter(
struct sci_base_object *object)
{
- struct scic_sds_phy *this_phy;
+ struct scic_sds_phy *sci_phy;
- this_phy = (struct scic_sds_phy *)object;
+ sci_phy = (struct scic_sds_phy *)object;
scic_sds_phy_set_starting_substate_handlers(
- this_phy, SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_IAF_UF
+ sci_phy, SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_IAF_UF
);
}
static void scic_sds_phy_starting_await_sas_power_substate_enter(
struct sci_base_object *object)
{
- struct scic_sds_phy *this_phy;
+ struct scic_sds_phy *sci_phy;
- this_phy = (struct scic_sds_phy *)object;
+ sci_phy = (struct scic_sds_phy *)object;
scic_sds_phy_set_starting_substate_handlers(
- this_phy, SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SAS_POWER
+ sci_phy, SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SAS_POWER
);
scic_sds_controller_power_control_queue_insert(
- scic_sds_phy_get_controller(this_phy),
- this_phy
+ scic_sds_phy_get_controller(sci_phy),
+ sci_phy
);
}
static void scic_sds_phy_starting_await_sas_power_substate_exit(
struct sci_base_object *object)
{
- struct scic_sds_phy *this_phy;
+ struct scic_sds_phy *sci_phy;
- this_phy = (struct scic_sds_phy *)object;
+ sci_phy = (struct scic_sds_phy *)object;
scic_sds_controller_power_control_queue_remove(
- scic_sds_phy_get_controller(this_phy), this_phy
+ scic_sds_phy_get_controller(sci_phy), sci_phy
);
}
static void scic_sds_phy_starting_await_sata_power_substate_enter(
struct sci_base_object *object)
{
- struct scic_sds_phy *this_phy;
+ struct scic_sds_phy *sci_phy;
- this_phy = (struct scic_sds_phy *)object;
+ sci_phy = (struct scic_sds_phy *)object;
scic_sds_phy_set_starting_substate_handlers(
- this_phy, SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SATA_POWER
+ sci_phy, SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SATA_POWER
);
scic_sds_controller_power_control_queue_insert(
- scic_sds_phy_get_controller(this_phy),
- this_phy
+ scic_sds_phy_get_controller(sci_phy),
+ sci_phy
);
}
static void scic_sds_phy_starting_await_sata_power_substate_exit(
struct sci_base_object *object)
{
- struct scic_sds_phy *this_phy;
+ struct scic_sds_phy *sci_phy;
- this_phy = (struct scic_sds_phy *)object;
+ sci_phy = (struct scic_sds_phy *)object;
scic_sds_controller_power_control_queue_remove(
- scic_sds_phy_get_controller(this_phy),
- this_phy
+ scic_sds_phy_get_controller(sci_phy),
+ sci_phy
);
}
/**
*
- * @this_phy: This is the struct scic_sds_phy object to stop.
+ * @sci_phy: This is the struct scic_sds_phy object to stop.
*
* This method will stop the struct scic_sds_phy object. This does not reset the
* protocol engine it just suspends it and places it in a state where it will
* not cause the end device to power up. none
*/
static void scu_link_layer_stop_protocol_engine(
- struct scic_sds_phy *this_phy)
+ struct scic_sds_phy *sci_phy)
{
u32 scu_sas_pcfg_value;
u32 enable_spinup_value;
/* Suspend the protocol engine and place it in a sata spinup hold state */
scu_sas_pcfg_value =
- readl(&this_phy->link_layer_registers->phy_configuration);
- scu_sas_pcfg_value |= (
- SCU_SAS_PCFG_GEN_BIT(OOB_RESET)
- | SCU_SAS_PCFG_GEN_BIT(SUSPEND_PROTOCOL_ENGINE)
- | SCU_SAS_PCFG_GEN_BIT(SATA_SPINUP_HOLD)
- );
+ readl(&sci_phy->link_layer_registers->phy_configuration);
+ scu_sas_pcfg_value |=
+ (SCU_SAS_PCFG_GEN_BIT(OOB_RESET) |
+ SCU_SAS_PCFG_GEN_BIT(SUSPEND_PROTOCOL_ENGINE) |
+ SCU_SAS_PCFG_GEN_BIT(SATA_SPINUP_HOLD));
writel(scu_sas_pcfg_value,
- &this_phy->link_layer_registers->phy_configuration);
+ &sci_phy->link_layer_registers->phy_configuration);
/* Disable the notify enable spinup primitives */
- enable_spinup_value = readl(&this_phy->link_layer_registers->notify_enable_spinup_control);
+ enable_spinup_value = readl(&sci_phy->link_layer_registers->notify_enable_spinup_control);
enable_spinup_value &= ~SCU_ENSPINUP_GEN_BIT(ENABLE);
- writel(enable_spinup_value, &this_phy->link_layer_registers->notify_enable_spinup_control);
+ writel(enable_spinup_value, &sci_phy->link_layer_registers->notify_enable_spinup_control);
}
/**
* This method will start the OOB/SN state machine for this struct scic_sds_phy object.
*/
static void scu_link_layer_start_oob(
- struct scic_sds_phy *this_phy)
+ struct scic_sds_phy *sci_phy)
{
u32 scu_sas_pcfg_value;
scu_sas_pcfg_value =
- readl(&this_phy->link_layer_registers->phy_configuration);
+ readl(&sci_phy->link_layer_registers->phy_configuration);
scu_sas_pcfg_value |= SCU_SAS_PCFG_GEN_BIT(OOB_ENABLE);
scu_sas_pcfg_value &=
- ~(SCU_SAS_PCFG_GEN_BIT(OOB_RESET) | SCU_SAS_PCFG_GEN_BIT(HARD_RESET));
+ ~(SCU_SAS_PCFG_GEN_BIT(OOB_RESET) |
+ SCU_SAS_PCFG_GEN_BIT(HARD_RESET));
writel(scu_sas_pcfg_value,
- &this_phy->link_layer_registers->phy_configuration);
+ &sci_phy->link_layer_registers->phy_configuration);
}
/**
* hard reset bit set.
*/
static void scu_link_layer_tx_hard_reset(
- struct scic_sds_phy *this_phy)
+ struct scic_sds_phy *sci_phy)
{
u32 phy_configuration_value;
* SAS Phys must wait for the HARD_RESET_TX event notification to transition
* to the starting state. */
phy_configuration_value =
- readl(&this_phy->link_layer_registers->phy_configuration);
+ readl(&sci_phy->link_layer_registers->phy_configuration);
phy_configuration_value |=
- (SCU_SAS_PCFG_GEN_BIT(HARD_RESET) | SCU_SAS_PCFG_GEN_BIT(OOB_RESET));
+ (SCU_SAS_PCFG_GEN_BIT(HARD_RESET) |
+ SCU_SAS_PCFG_GEN_BIT(OOB_RESET));
writel(phy_configuration_value,
- &this_phy->link_layer_registers->phy_configuration);
+ &sci_phy->link_layer_registers->phy_configuration);
/* Now take the OOB state machine out of reset */
phy_configuration_value |= SCU_SAS_PCFG_GEN_BIT(OOB_ENABLE);
phy_configuration_value &= ~SCU_SAS_PCFG_GEN_BIT(OOB_RESET);
writel(phy_configuration_value,
- &this_phy->link_layer_registers->phy_configuration);
+ &sci_phy->link_layer_registers->phy_configuration);
}
/*
static void scic_sds_phy_initial_state_enter(
struct sci_base_object *object)
{
- struct scic_sds_phy *this_phy;
+ struct scic_sds_phy *sci_phy;
- this_phy = (struct scic_sds_phy *)object;
+ sci_phy = (struct scic_sds_phy *)object;
- scic_sds_phy_set_base_state_handlers(this_phy, SCI_BASE_PHY_STATE_INITIAL);
+ scic_sds_phy_set_base_state_handlers(sci_phy, SCI_BASE_PHY_STATE_INITIAL);
}
/**
static void scic_sds_phy_starting_state_enter(
struct sci_base_object *object)
{
- struct scic_sds_phy *this_phy;
+ struct scic_sds_phy *sci_phy;
- this_phy = (struct scic_sds_phy *)object;
+ sci_phy = (struct scic_sds_phy *)object;
- scic_sds_phy_set_base_state_handlers(this_phy, SCI_BASE_PHY_STATE_STARTING);
+ scic_sds_phy_set_base_state_handlers(sci_phy, SCI_BASE_PHY_STATE_STARTING);
- scu_link_layer_stop_protocol_engine(this_phy);
- scu_link_layer_start_oob(this_phy);
+ scu_link_layer_stop_protocol_engine(sci_phy);
+ scu_link_layer_start_oob(sci_phy);
/* We don't know what kind of phy we are going to be just yet */
- this_phy->protocol = SCIC_SDS_PHY_PROTOCOL_UNKNOWN;
- this_phy->bcn_received_while_port_unassigned = false;
+ sci_phy->protocol = SCIC_SDS_PHY_PROTOCOL_UNKNOWN;
+ sci_phy->bcn_received_while_port_unassigned = false;
/* Change over to the starting substate machine to continue */
- sci_base_state_machine_start(&this_phy->starting_substate_machine);
+ sci_base_state_machine_start(&sci_phy->starting_substate_machine);
- if (this_phy->state_machine.previous_state_id
+ if (sci_phy->state_machine.previous_state_id
== SCI_BASE_PHY_STATE_READY) {
scic_sds_controller_link_down(
- scic_sds_phy_get_controller(this_phy),
- scic_sds_phy_get_port(this_phy),
- this_phy
+ scic_sds_phy_get_controller(sci_phy),
+ scic_sds_phy_get_port(sci_phy),
+ sci_phy
);
}
}
static void scic_sds_phy_ready_state_enter(
struct sci_base_object *object)
{
- struct scic_sds_phy *this_phy;
+ struct scic_sds_phy *sci_phy;
- this_phy = (struct scic_sds_phy *)object;
+ sci_phy = (struct scic_sds_phy *)object;
- scic_sds_phy_set_base_state_handlers(this_phy, SCI_BASE_PHY_STATE_READY);
+ scic_sds_phy_set_base_state_handlers(sci_phy, SCI_BASE_PHY_STATE_READY);
scic_sds_controller_link_up(
- scic_sds_phy_get_controller(this_phy),
- scic_sds_phy_get_port(this_phy),
- this_phy
+ scic_sds_phy_get_controller(sci_phy),
+ scic_sds_phy_get_port(sci_phy),
+ sci_phy
);
}
static void scic_sds_phy_ready_state_exit(
struct sci_base_object *object)
{
- struct scic_sds_phy *this_phy;
+ struct scic_sds_phy *sci_phy;
- this_phy = (struct scic_sds_phy *)object;
+ sci_phy = (struct scic_sds_phy *)object;
- scic_sds_phy_suspend(this_phy);
+ scic_sds_phy_suspend(sci_phy);
}
/**
static void scic_sds_phy_resetting_state_enter(
struct sci_base_object *object)
{
- struct scic_sds_phy *this_phy;
+ struct scic_sds_phy *sci_phy;
- this_phy = (struct scic_sds_phy *)object;
+ sci_phy = (struct scic_sds_phy *)object;
- scic_sds_phy_set_base_state_handlers(this_phy, SCI_BASE_PHY_STATE_RESETTING);
+ scic_sds_phy_set_base_state_handlers(sci_phy, SCI_BASE_PHY_STATE_RESETTING);
/*
* The phy is being reset, therefore deactivate it from the port.
* In the resetting state we don't notify the user regarding
* link up and link down notifications. */
- scic_sds_port_deactivate_phy(this_phy->owning_port, this_phy, false);
+ scic_sds_port_deactivate_phy(sci_phy->owning_port, sci_phy, false);
- if (this_phy->protocol == SCIC_SDS_PHY_PROTOCOL_SAS) {
- scu_link_layer_tx_hard_reset(this_phy);
+ if (sci_phy->protocol == SCIC_SDS_PHY_PROTOCOL_SAS) {
+ scu_link_layer_tx_hard_reset(sci_phy);
} else {
/*
- * The SCU does not need to have a discrete reset state so just go back to
- * the starting state. */
- sci_base_state_machine_change_state(&this_phy->state_machine,
- SCI_BASE_PHY_STATE_STARTING);
+ * The SCU does not need to have a discrete reset state so
+ * just go back to the starting state.
+ */
+ sci_base_state_machine_change_state(
+ &sci_phy->state_machine,
+ SCI_BASE_PHY_STATE_STARTING);
}
}
static void scic_sds_phy_final_state_enter(
struct sci_base_object *object)
{
- struct scic_sds_phy *this_phy;
+ struct scic_sds_phy *sci_phy;
- this_phy = (struct scic_sds_phy *)object;
+ sci_phy = (struct scic_sds_phy *)object;
- scic_sds_phy_set_base_state_handlers(this_phy, SCI_BASE_PHY_STATE_FINAL);
+ scic_sds_phy_set_base_state_handlers(sci_phy, SCI_BASE_PHY_STATE_FINAL);
/* Nothing to do here */
}
/**
*
- * @this_port: This is the port object to which the phy is being assigned.
+ * @sci_port: This is the port object to which the phy is being assigned.
* @phy_index: This is the phy index that is being assigned to the port.
*
* This method will return a true value if the specified phy can be assigned to
* port
*/
bool scic_sds_port_is_valid_phy_assignment(
- struct scic_sds_port *this_port,
+ struct scic_sds_port *sci_port,
u32 phy_index)
{
/* Initialize to invalid value. */
u32 existing_phy_index = SCI_MAX_PHYS;
u32 index;
- if ((this_port->physical_port_index == 1) && (phy_index != 1)) {
+ if ((sci_port->physical_port_index == 1) && (phy_index != 1)) {
return false;
}
- if (this_port->physical_port_index == 3 && phy_index != 3) {
+ if (sci_port->physical_port_index == 3 && phy_index != 3) {
return false;
}
if (
- (this_port->physical_port_index == 2)
+ (sci_port->physical_port_index == 2)
&& ((phy_index == 0) || (phy_index == 1))
) {
return false;
}
for (index = 0; index < SCI_MAX_PHYS; index++) {
- if ((this_port->phy_table[index] != NULL)
+ if ((sci_port->phy_table[index] != NULL)
&& (index != phy_index)) {
existing_phy_index = index;
}
* operating at the same maximum link rate. */
if (
(existing_phy_index < SCI_MAX_PHYS)
- && (this_port->owning_controller->user_parameters.sds1.phys[
+ && (sci_port->owning_controller->user_parameters.sds1.phys[
phy_index].max_speed_generation !=
- this_port->owning_controller->user_parameters.sds1.phys[
+ sci_port->owning_controller->user_parameters.sds1.phys[
existing_phy_index].max_speed_generation)
)
return false;
/**
* This method requests a list (mask) of the phys contained in the supplied SAS
* port.
- * @this_port: a handle corresponding to the SAS port for which to return the
+ * @sci_port: a handle corresponding to the SAS port for which to return the
* phy mask.
*
* Return a bit mask indicating which phys are a part of this port. Each bit
* corresponds to a phy identifier (e.g. bit 0 = phy id 0).
*/
-static u32 scic_sds_port_get_phys(struct scic_sds_port *this_port)
+static u32 scic_sds_port_get_phys(struct scic_sds_port *sci_port)
{
u32 index;
u32 mask;
mask = 0;
for (index = 0; index < SCI_MAX_PHYS; index++) {
- if (this_port->phy_table[index] != NULL) {
+ if (sci_port->phy_table[index] != NULL) {
mask |= (1 << index);
}
}
/**
*
- * @this_port: This is the port object for which to determine if the phy mask
+ * @sci_port: This is the port object for which to determine if the phy mask
* can be supported.
*
* This method will return a true value if the port's phy mask can be supported
* port false if this is not a valid phy assignment for the port
*/
static bool scic_sds_port_is_phy_mask_valid(
- struct scic_sds_port *this_port,
+ struct scic_sds_port *sci_port,
u32 phy_mask)
{
- if (this_port->physical_port_index == 0) {
+ if (sci_port->physical_port_index == 0) {
if (((phy_mask & 0x0F) == 0x0F)
|| ((phy_mask & 0x03) == 0x03)
|| ((phy_mask & 0x01) == 0x01)
|| (phy_mask == 0))
return true;
- } else if (this_port->physical_port_index == 1) {
+ } else if (sci_port->physical_port_index == 1) {
if (((phy_mask & 0x02) == 0x02)
|| (phy_mask == 0))
return true;
- } else if (this_port->physical_port_index == 2) {
+ } else if (sci_port->physical_port_index == 2) {
if (((phy_mask & 0x0C) == 0x0C)
|| ((phy_mask & 0x04) == 0x04)
|| (phy_mask == 0))
return true;
- } else if (this_port->physical_port_index == 3) {
+ } else if (sci_port->physical_port_index == 3) {
if (((phy_mask & 0x08) == 0x08)
|| (phy_mask == 0))
return true;
/**
*
- * @this_port: This parameter specifies the port from which to return a
+ * @sci_port: This parameter specifies the port from which to return a
* connected phy.
*
* This method retrieves a currently active (i.e. connected) phy contained in
* object that is active in the port.
*/
static struct scic_sds_phy *scic_sds_port_get_a_connected_phy(
- struct scic_sds_port *this_port
+ struct scic_sds_port *sci_port
) {
u32 index;
struct scic_sds_phy *phy;
/*
* Ensure that the phy is both part of the port and currently
* connected to the remote end-point. */
- phy = this_port->phy_table[index];
+ phy = sci_port->phy_table[index];
if (
(phy != NULL)
- && scic_sds_port_active_phy(this_port, phy)
+ && scic_sds_port_active_phy(sci_port, phy)
) {
return phy;
}
/**
* scic_sds_port_add_phy() -
- * @this_port: This parameter specifies the port in which the phy will be added.
- * @the_phy: This parameter is the phy which is to be added to the port.
+ * @sci_port: This parameter specifies the port in which the phy will be added.
+ * @sci_phy: This parameter is the phy which is to be added to the port.
*
* This method will add a PHY to the selected port. This method returns an
* enum sci_status. SCI_SUCCESS the phy has been added to the port. Any other status
* is failre to add the phy to the port.
*/
enum sci_status scic_sds_port_add_phy(
- struct scic_sds_port *this_port,
- struct scic_sds_phy *the_phy)
+ struct scic_sds_port *sci_port,
+ struct scic_sds_phy *sci_phy)
{
- return this_port->state_handlers->add_phy_handler(
- this_port, the_phy);
+ return sci_port->state_handlers->add_phy_handler(
+ sci_port, sci_phy);
}
/**
* scic_sds_port_remove_phy() -
- * @this_port: This parameter specifies the port in which the phy will be added.
- * @the_phy: This parameter is the phy which is to be added to the port.
+ * @sci_port: This parameter specifies the port in which the phy will be added.
+ * @sci_phy: This parameter is the phy which is to be added to the port.
*
* This method will remove the PHY from the selected PORT. This method returns
* an enum sci_status. SCI_SUCCESS the phy has been removed from the port. Any other
* status is failre to add the phy to the port.
*/
enum sci_status scic_sds_port_remove_phy(
- struct scic_sds_port *this_port,
- struct scic_sds_phy *the_phy)
+ struct scic_sds_port *sci_port,
+ struct scic_sds_phy *sci_phy)
{
- return this_port->state_handlers->remove_phy_handler(
- this_port, the_phy);
+ return sci_port->state_handlers->remove_phy_handler(
+ sci_port, sci_phy);
}
/**
* This method requests the SAS address for the supplied SAS port from the SCI
* implementation.
- * @this_port: a handle corresponding to the SAS port for which to return the
+ * @sci_port: a handle corresponding to the SAS port for which to return the
* SAS address.
* @sas_address: This parameter specifies a pointer to a SAS address structure
* into which the core will copy the SAS address for the port.
*
*/
void scic_sds_port_get_sas_address(
- struct scic_sds_port *this_port,
+ struct scic_sds_port *sci_port,
struct sci_sas_address *sas_address)
{
u32 index;
sas_address->low = 0;
for (index = 0; index < SCI_MAX_PHYS; index++) {
- if (this_port->phy_table[index] != NULL) {
- scic_sds_phy_get_sas_address(this_port->phy_table[index], sas_address);
+ if (sci_port->phy_table[index] != NULL) {
+ scic_sds_phy_get_sas_address(sci_port->phy_table[index], sas_address);
}
}
}
/**
* This method will indicate which protocols are supported by this port.
- * @this_port: a handle corresponding to the SAS port for which to return the
+ * @sci_port: a handle corresponding to the SAS port for which to return the
* supported protocols.
* @protocols: This parameter specifies a pointer to an IAF protocol field
* structure into which the core will copy the protocol values for the port.
*
*/
static void scic_sds_port_get_protocols(
- struct scic_sds_port *this_port,
+ struct scic_sds_port *sci_port,
struct sci_sas_identify_address_frame_protocols *protocols)
{
u8 index;
protocols->u.all = 0;
for (index = 0; index < SCI_MAX_PHYS; index++) {
- if (this_port->phy_table[index] != NULL) {
- scic_sds_phy_get_protocols(this_port->phy_table[index], protocols);
+ if (sci_port->phy_table[index] != NULL) {
+ scic_sds_phy_get_protocols(sci_port->phy_table[index], protocols);
}
}
}
/**
* This method requests the SAS address for the device directly attached to
* this SAS port.
- * @this_port: a handle corresponding to the SAS port for which to return the
+ * @sci_port: a handle corresponding to the SAS port for which to return the
* SAS address.
* @sas_address: This parameter specifies a pointer to a SAS address structure
* into which the core will copy the SAS address for the device directly
*
*/
void scic_sds_port_get_attached_sas_address(
- struct scic_sds_port *this_port,
+ struct scic_sds_port *sci_port,
struct sci_sas_address *sas_address)
{
struct sci_sas_identify_address_frame_protocols protocols;
/*
* Ensure that the phy is both part of the port and currently
* connected to the remote end-point. */
- phy = scic_sds_port_get_a_connected_phy(this_port);
+ phy = scic_sds_port_get_a_connected_phy(sci_port);
if (phy != NULL) {
scic_sds_phy_get_attached_phy_protocols(phy, &protocols);
/**
* This method will indicate which protocols are supported by this remote
* device.
- * @this_port: a handle corresponding to the SAS port for which to return the
+ * @sci_port: a handle corresponding to the SAS port for which to return the
* supported protocols.
* @protocols: This parameter specifies a pointer to an IAF protocol field
* structure into which the core will copy the protocol values for the port.
*
*/
void scic_sds_port_get_attached_protocols(
- struct scic_sds_port *this_port,
+ struct scic_sds_port *sci_port,
struct sci_sas_identify_address_frame_protocols *protocols)
{
struct scic_sds_phy *phy;
/*
* Ensure that the phy is both part of the port and currently
* connected to the remote end-point. */
- phy = scic_sds_port_get_a_connected_phy(this_port);
+ phy = scic_sds_port_get_a_connected_phy(sci_port);
if (phy != NULL)
scic_sds_phy_get_attached_phy_protocols(phy, protocols);
else
* This method performs initialization of the supplied port. Initialization
* includes: - state machine initialization - member variable initialization
* - configuring the phy_mask
- * @this_port:
+ * @sci_port:
* @transport_layer_registers:
* @port_task_scheduler_registers:
* @port_configuration_regsiter:
* if the phy being added to the port
*/
enum sci_status scic_sds_port_initialize(
- struct scic_sds_port *this_port,
+ struct scic_sds_port *sci_port,
void __iomem *port_task_scheduler_registers,
void __iomem *port_configuration_regsiter,
void __iomem *viit_registers)
{
- this_port->port_task_scheduler_registers = port_task_scheduler_registers;
- this_port->port_pe_configuration_register = port_configuration_regsiter;
- this_port->viit_registers = viit_registers;
+ sci_port->port_task_scheduler_registers = port_task_scheduler_registers;
+ sci_port->port_pe_configuration_register = port_configuration_regsiter;
+ sci_port->viit_registers = viit_registers;
return SCI_SUCCESS;
}
/**
* This method assigns the direct attached device ID for this port.
*
- * @param[in] this_port The port for which the direct attached device id is to
+ * @param[in] sci_port The port for which the direct attached device id is to
* be assigned.
* @param[in] device_id The direct attached device ID to assign to the port.
* This will be the RNi for the device
*/
void scic_sds_port_setup_transports(
- struct scic_sds_port *this_port,
+ struct scic_sds_port *sci_port,
u32 device_id)
{
u8 index;
for (index = 0; index < SCI_MAX_PHYS; index++) {
- if (this_port->active_phy_mask & (1 << index))
- scic_sds_phy_setup_transport(this_port->phy_table[index], device_id);
+ if (sci_port->active_phy_mask & (1 << index))
+ scic_sds_phy_setup_transport(sci_port->phy_table[index], device_id);
}
}
/**
*
- * @this_port: This is the port on which the phy should be enabled.
- * @the_phy: This is the specific phy which to enable.
+ * @sci_port: This is the port on which the phy should be enabled.
+ * @sci_phy: This is the specific phy which to enable.
* @do_notify_user: This parameter specifies whether to inform the user (via
* scic_cb_port_link_up()) as to the fact that a new phy as become ready.
*
/**
*
- * @this_port: This is the port on which the phy should be disabled.
- * @the_phy: This is the specific phy which to disabled.
+ * @sci_port: This is the port on which the phy should be disabled.
+ * @sci_phy: This is the specific phy which to disabled.
*
* This function will disable the phy and report that the phy is not valid for
* this port object. None
* This method returns false if the port only has a single phy object assigned.
* If there are no phys or more than one phy then the method will return
* true.
- * @this_port: The port for which the wide port condition is to be checked.
+ * @sci_port: The port for which the wide port condition is to be checked.
*
* bool true Is returned if this is a wide ported port. false Is returned if
* this is a narrow port.
*/
-static bool scic_sds_port_is_wide(struct scic_sds_port *this_port)
+static bool scic_sds_port_is_wide(struct scic_sds_port *sci_port)
{
u32 index;
u32 phy_count = 0;
for (index = 0; index < SCI_MAX_PHYS; index++) {
- if (this_port->phy_table[index] != NULL) {
+ if (sci_port->phy_table[index] != NULL) {
phy_count++;
}
}
* port wants the PHY to continue on to the link up state then the port
* layer must return true. If the port object returns false the phy object
* must halt its attempt to go link up.
- * @this_port: The port associated with the phy object.
- * @the_phy: The phy object that is trying to go link up.
+ * @sci_port: The port associated with the phy object.
+ * @sci_phy: The phy object that is trying to go link up.
*
* true if the phy object can continue to the link up condition. true Is
* returned if this phy can continue to the ready state. false Is returned if
* devices this could become an invalid port configuration.
*/
bool scic_sds_port_link_detected(
- struct scic_sds_port *this_port,
- struct scic_sds_phy *the_phy)
+ struct scic_sds_port *sci_port,
+ struct scic_sds_phy *sci_phy)
{
struct sci_sas_identify_address_frame_protocols protocols;
- scic_sds_phy_get_attached_phy_protocols(the_phy, &protocols);
+ scic_sds_phy_get_attached_phy_protocols(sci_phy, &protocols);
if (
- (this_port->logical_port_index != SCIC_SDS_DUMMY_PORT)
+ (sci_port->logical_port_index != SCIC_SDS_DUMMY_PORT)
&& (protocols.u.bits.stp_target)
- && scic_sds_port_is_wide(this_port)
+ && scic_sds_port_is_wide(sci_port)
) {
- scic_sds_port_invalid_link_up(this_port, the_phy);
+ scic_sds_port_invalid_link_up(sci_port, sci_phy);
return false;
}
/**
* This method is the entry point for the phy to inform the port that it is now
* in a ready state
- * @this_port:
+ * @sci_port:
*
*
*/
void scic_sds_port_link_up(
- struct scic_sds_port *this_port,
- struct scic_sds_phy *the_phy)
+ struct scic_sds_port *sci_port,
+ struct scic_sds_phy *sci_phy)
{
- the_phy->is_in_link_training = false;
+ sci_phy->is_in_link_training = false;
- this_port->state_handlers->link_up_handler(this_port, the_phy);
+ sci_port->state_handlers->link_up_handler(sci_port, sci_phy);
}
/**
* This method is the entry point for the phy to inform the port that it is no
* longer in a ready state
- * @this_port:
+ * @sci_port:
*
*
*/
void scic_sds_port_link_down(
- struct scic_sds_port *this_port,
- struct scic_sds_phy *the_phy)
+ struct scic_sds_port *sci_port,
+ struct scic_sds_phy *sci_phy)
{
- this_port->state_handlers->link_down_handler(this_port, the_phy);
+ sci_port->state_handlers->link_down_handler(sci_port, sci_phy);
}
/**
* This method is called to start an IO request on this port.
- * @this_port:
- * @the_device:
- * @the_io_request:
+ * @sci_port:
+ * @sci_dev:
+ * @sci_req:
*
* enum sci_status
*/
enum sci_status scic_sds_port_start_io(
- struct scic_sds_port *this_port,
- struct scic_sds_remote_device *the_device,
- struct scic_sds_request *the_io_request)
+ struct scic_sds_port *sci_port,
+ struct scic_sds_remote_device *sci_dev,
+ struct scic_sds_request *sci_req)
{
- return this_port->state_handlers->start_io_handler(
- this_port, the_device, the_io_request);
+ return sci_port->state_handlers->start_io_handler(
+ sci_port, sci_dev, sci_req);
}
/**
* This method is called to complete an IO request to the port.
- * @this_port:
- * @the_device:
- * @the_io_request:
+ * @sci_port:
+ * @sci_dev:
+ * @sci_req:
*
* enum sci_status
*/
enum sci_status scic_sds_port_complete_io(
- struct scic_sds_port *this_port,
- struct scic_sds_remote_device *the_device,
- struct scic_sds_request *the_io_request)
+ struct scic_sds_port *sci_port,
+ struct scic_sds_remote_device *sci_dev,
+ struct scic_sds_request *sci_req)
{
- return this_port->state_handlers->complete_io_handler(
- this_port, the_device, the_io_request);
+ return sci_port->state_handlers->complete_io_handler(
+ sci_port, sci_dev, sci_req);
}
/**
*
*
*/
-static void scic_sds_port_update_viit_entry(struct scic_sds_port *this_port)
+static void scic_sds_port_update_viit_entry(struct scic_sds_port *sci_port)
{
struct sci_sas_address sas_address;
- scic_sds_port_get_sas_address(this_port, &sas_address);
+ scic_sds_port_get_sas_address(sci_port, &sas_address);
writel(sas_address.high,
- &this_port->viit_registers->initiator_sas_address_hi);
+ &sci_port->viit_registers->initiator_sas_address_hi);
writel(sas_address.low,
- &this_port->viit_registers->initiator_sas_address_lo);
+ &sci_port->viit_registers->initiator_sas_address_lo);
/* This value get cleared just in case its not already cleared */
- writel(0, &this_port->viit_registers->reserved);
+ writel(0, &sci_port->viit_registers->reserved);
/* We are required to update the status register last */
writel(SCU_VIIT_ENTRY_ID_VIIT |
SCU_VIIT_IPPT_INITIATOR |
- ((1 << this_port->physical_port_index) << SCU_VIIT_ENTRY_LPVIE_SHIFT) |
+ ((1 << sci_port->physical_port_index) << SCU_VIIT_ENTRY_LPVIE_SHIFT) |
SCU_VIIT_STATUS_ALL_VALID,
- &this_port->viit_registers->status);
+ &sci_port->viit_registers->status);
}
/**
* This method returns the maximum allowed speed for data transfers on this
* port. This maximum allowed speed evaluates to the maximum speed of the
* slowest phy in the port.
- * @this_port: This parameter specifies the port for which to retrieve the
+ * @sci_port: This parameter specifies the port for which to retrieve the
* maximum allowed speed.
*
* This method returns the maximum negotiated speed of the slowest phy in the
* port.
*/
enum sas_linkrate scic_sds_port_get_max_allowed_speed(
- struct scic_sds_port *this_port)
+ struct scic_sds_port *sci_port)
{
u16 index;
enum sas_linkrate max_allowed_speed = SAS_LINK_RATE_6_0_GBPS;
* Loop through all of the phys in this port and find the phy with the
* lowest maximum link rate. */
for (index = 0; index < SCI_MAX_PHYS; index++) {
- phy = this_port->phy_table[index];
+ phy = sci_port->phy_table[index];
if (
(phy != NULL)
- && (scic_sds_port_active_phy(this_port, phy) == true)
+ && (scic_sds_port_active_phy(sci_port, phy) == true)
&& (phy->max_negotiated_speed < max_allowed_speed)
)
max_allowed_speed = phy->max_negotiated_speed;
/**
* This method passes the event to core user.
- * @this_port: The port that a BCN happens.
- * @this_phy: The phy that receives BCN.
+ * @sci_port: The port that a BCN happens.
+ * @sci_phy: The phy that receives BCN.
*
*/
void scic_sds_port_broadcast_change_received(
/**
* This API methhod enables the broadcast change notification from underneath
* hardware.
- * @this_port: The port that a BCN had been disabled from.
+ * @sci_port: The port that a BCN had been disabled from.
*
*/
void scic_port_enable_broadcast_change_notification(
/**
*
- * @this_port: This is the struct scic_sds_port object that which has a phy that has
+ * @sci_port: This is the struct scic_sds_port object that which has a phy that has
* gone link up.
- * @the_phy: This is the struct scic_sds_phy object that has gone link up.
+ * @sci_phy: This is the struct scic_sds_phy object that has gone link up.
*
* This method is the ready waiting substate link up handler for the
* struct scic_sds_port object. This methos will report the link up condition for
* this port and will transition to the ready operational substate. none
*/
static void scic_sds_port_ready_waiting_substate_link_up_handler(
- struct scic_sds_port *this_port,
- struct scic_sds_phy *the_phy)
+ struct scic_sds_port *sci_port,
+ struct scic_sds_phy *sci_phy)
{
/*
* Since this is the first phy going link up for the port we can just enable
* it and continue. */
- scic_sds_port_activate_phy(this_port, the_phy, true);
+ scic_sds_port_activate_phy(sci_port, sci_phy, true);
sci_base_state_machine_change_state(
- &this_port->ready_substate_machine,
+ &sci_port->ready_substate_machine,
SCIC_SDS_PORT_READY_SUBSTATE_OPERATIONAL
);
}
/**
* scic_sds_port_ready_operational_substate_link_up_handler() -
- * @this_port: This is the struct scic_sds_port object that which has a phy that has
+ * @sci_port: This is the struct scic_sds_port object that which has a phy that has
* gone link up.
- * @the_phy: This is the struct scic_sds_phy object that has gone link up.
+ * @sci_phy: This is the struct scic_sds_phy object that has gone link up.
*
* This method is the ready operational substate link up handler for the
* struct scic_sds_port object. This function notifies the SCI User that the phy has
* gone link up. none
*/
static void scic_sds_port_ready_operational_substate_link_up_handler(
- struct scic_sds_port *this_port,
- struct scic_sds_phy *the_phy)
+ struct scic_sds_port *sci_port,
+ struct scic_sds_phy *sci_phy)
{
- scic_sds_port_general_link_up_handler(this_port, the_phy, true);
+ scic_sds_port_general_link_up_handler(sci_port, sci_phy, true);
}
/**
/**
*
- * @this_port: This is the struct scic_sds_port object to suspend.
+ * @sci_port: This is the struct scic_sds_port object to suspend.
*
* This method will susped the port task scheduler for this port object. none
*/
/**
*
- * @this_port: This is the struct scic_sds_port object to resume.
+ * @sci_port: This is the struct scic_sds_port object to resume.
*
* This method will resume the port task scheduler for this port object. none
*/
static void scic_sds_port_ready_substate_waiting_enter(
struct sci_base_object *object)
{
- struct scic_sds_port *this_port = (struct scic_sds_port *)object;
+ struct scic_sds_port *sci_port = (struct scic_sds_port *)object;
scic_sds_port_set_ready_state_handlers(
- this_port, SCIC_SDS_PORT_READY_SUBSTATE_WAITING
+ sci_port, SCIC_SDS_PORT_READY_SUBSTATE_WAITING
);
- scic_sds_port_suspend_port_task_scheduler(this_port);
+ scic_sds_port_suspend_port_task_scheduler(sci_port);
- this_port->not_ready_reason = SCIC_PORT_NOT_READY_NO_ACTIVE_PHYS;
+ sci_port->not_ready_reason = SCIC_PORT_NOT_READY_NO_ACTIVE_PHYS;
- if (this_port->active_phy_mask != 0) {
+ if (sci_port->active_phy_mask != 0) {
/* At least one of the phys on the port is ready */
sci_base_state_machine_change_state(
- &this_port->ready_substate_machine,
+ &sci_port->ready_substate_machine,
SCIC_SDS_PORT_READY_SUBSTATE_OPERATIONAL
);
}
static void scic_sds_port_ready_substate_configuring_exit(
struct sci_base_object *object)
{
- struct scic_sds_port *this_port = (struct scic_sds_port *)object;
+ struct scic_sds_port *sci_port = (struct scic_sds_port *)object;
- scic_sds_port_suspend_port_task_scheduler(this_port);
+ scic_sds_port_suspend_port_task_scheduler(sci_port);
}
/* --------------------------------------------------------------------------- */
/**
*
- * @this_port: This is the port object which to suspend.
+ * @sci_port: This is the port object which to suspend.
*
* This method will enable the SCU Port Task Scheduler for this port object but
* will leave the port task scheduler in a suspended state. none
/**
*
- * @this_port: This is the port object which to resume.
+ * @sci_port: This is the port object which to resume.
*
* This method will disable the SCU port task scheduler for this port object.
* none
static void scic_sds_port_stopped_state_enter(
struct sci_base_object *object)
{
- struct scic_sds_port *this_port;
+ struct scic_sds_port *sci_port;
- this_port = (struct scic_sds_port *)object;
+ sci_port = (struct scic_sds_port *)object;
scic_sds_port_set_base_state_handlers(
- this_port, SCI_BASE_PORT_STATE_STOPPED
+ sci_port, SCI_BASE_PORT_STATE_STOPPED
);
if (
SCI_BASE_PORT_STATE_STOPPING
- == this_port->state_machine.previous_state_id
+ == sci_port->state_machine.previous_state_id
) {
/*
* If we enter this state becasuse of a request to stop
* the port then we want to disable the hardwares port
* task scheduler. */
- scic_sds_port_disable_port_task_scheduler(this_port);
+ scic_sds_port_disable_port_task_scheduler(sci_port);
}
}
static void scic_sds_port_stopped_state_exit(
struct sci_base_object *object)
{
- struct scic_sds_port *this_port;
+ struct scic_sds_port *sci_port;
- this_port = (struct scic_sds_port *)object;
+ sci_port = (struct scic_sds_port *)object;
/* Enable and suspend the port task scheduler */
- scic_sds_port_enable_port_task_scheduler(this_port);
+ scic_sds_port_enable_port_task_scheduler(sci_port);
}
/**
static void scic_sds_port_resetting_state_enter(
struct sci_base_object *object)
{
- struct scic_sds_port *this_port;
+ struct scic_sds_port *sci_port;
- this_port = (struct scic_sds_port *)object;
+ sci_port = (struct scic_sds_port *)object;
scic_sds_port_set_base_state_handlers(
- this_port, SCI_BASE_PORT_STATE_RESETTING
+ sci_port, SCI_BASE_PORT_STATE_RESETTING
);
}
static void scic_sds_port_stopping_state_enter(
struct sci_base_object *object)
{
- struct scic_sds_port *this_port;
+ struct scic_sds_port *sci_port;
- this_port = (struct scic_sds_port *)object;
+ sci_port = (struct scic_sds_port *)object;
scic_sds_port_set_base_state_handlers(
- this_port, SCI_BASE_PORT_STATE_STOPPING
+ sci_port, SCI_BASE_PORT_STATE_STOPPING
);
}
(((port)->active_phy_mask & (1 << (phy)->phy_index)) != 0)
void scic_sds_port_construct(
- struct scic_sds_port *this_port,
+ struct scic_sds_port *sci_port,
u8 port_index,
- struct scic_sds_controller *owning_controller);
+ struct scic_sds_controller *scic);
enum sci_status scic_sds_port_initialize(
- struct scic_sds_port *this_port,
+ struct scic_sds_port *sci_port,
void __iomem *port_task_scheduler_registers,
void __iomem *port_configuration_regsiter,
void __iomem *viit_registers);
enum sci_status scic_sds_port_add_phy(
- struct scic_sds_port *this_port,
- struct scic_sds_phy *the_phy);
+ struct scic_sds_port *sci_port,
+ struct scic_sds_phy *sci_phy);
enum sci_status scic_sds_port_remove_phy(
- struct scic_sds_port *this_port,
- struct scic_sds_phy *the_phy);
+ struct scic_sds_port *sci_port,
+ struct scic_sds_phy *sci_phy);
void scic_sds_port_setup_transports(
- struct scic_sds_port *this_port,
+ struct scic_sds_port *sci_port,
u32 device_id);
void scic_sds_port_deactivate_phy(
- struct scic_sds_port *this_port,
- struct scic_sds_phy *phy,
+ struct scic_sds_port *sci_port,
+ struct scic_sds_phy *sci_phy,
bool do_notify_user);
bool scic_sds_port_link_detected(
- struct scic_sds_port *this_port,
- struct scic_sds_phy *phy);
+ struct scic_sds_port *sci_port,
+ struct scic_sds_phy *sci_phy);
void scic_sds_port_link_up(
- struct scic_sds_port *this_port,
- struct scic_sds_phy *phy);
+ struct scic_sds_port *sci_port,
+ struct scic_sds_phy *sci_phy);
void scic_sds_port_link_down(
- struct scic_sds_port *this_port,
- struct scic_sds_phy *phy);
+ struct scic_sds_port *sci_port,
+ struct scic_sds_phy *sci_phy);
enum sci_status scic_sds_port_start_io(
- struct scic_sds_port *this_port,
- struct scic_sds_remote_device *the_device,
- struct scic_sds_request *the_io_request);
+ struct scic_sds_port *sci_port,
+ struct scic_sds_remote_device *sci_dev,
+ struct scic_sds_request *sci_req);
enum sci_status scic_sds_port_complete_io(
- struct scic_sds_port *this_port,
- struct scic_sds_remote_device *the_device,
- struct scic_sds_request *the_io_request);
+ struct scic_sds_port *sci_port,
+ struct scic_sds_remote_device *sci_dev,
+ struct scic_sds_request *sci_req);
enum sas_linkrate scic_sds_port_get_max_allowed_speed(
- struct scic_sds_port *this_port);
+ struct scic_sds_port *sci_port);
void scic_sds_port_broadcast_change_received(
- struct scic_sds_port *this_port,
- struct scic_sds_phy *this_phy);
+ struct scic_sds_port *sci_port,
+ struct scic_sds_phy *sci_phy);
bool scic_sds_port_is_valid_phy_assignment(
- struct scic_sds_port *this_port,
+ struct scic_sds_port *sci_port,
u32 phy_index);
void scic_sds_port_get_sas_address(
- struct scic_sds_port *this_port,
+ struct scic_sds_port *sci_port,
struct sci_sas_address *sas_address);
void scic_sds_port_get_attached_sas_address(
- struct scic_sds_port *this_port,
+ struct scic_sds_port *sci_port,
struct sci_sas_address *sas_address);
void scic_sds_port_get_attached_protocols(
- struct scic_sds_port *this_port,
+ struct scic_sds_port *sci_port,
struct sci_sas_identify_address_frame_protocols *protocols);
#endif /* _SCIC_SDS_PORT_H_ */
static void scic_sds_remote_device_get_info_from_smp_discover_response(
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
struct smp_response_discover *discover_response)
{
- /* decode discover_response to set sas_address to this_device. */
- this_device->device_address.high =
+ /* decode discover_response to set sas_address to sci_dev. */
+ sci_dev->device_address.high =
discover_response->attached_sas_address.high;
- this_device->device_address.low =
+ sci_dev->device_address.low =
discover_response->attached_sas_address.low;
- this_device->target_protocols.u.all = discover_response->protocols.u.all;
+ sci_dev->target_protocols.u.all = discover_response->protocols.u.all;
}
struct smp_response_discover *discover_response)
{
enum sci_status status;
- struct scic_sds_controller *the_controller;
+ struct scic_sds_controller *scic;
- the_controller = scic_sds_port_get_controller(sci_dev->owning_port);
+ scic = scic_sds_port_get_controller(sci_dev->owning_port);
scic_sds_remote_device_get_info_from_smp_discover_response(
sci_dev, discover_response);
status = scic_sds_controller_allocate_remote_node_context(
- the_controller, sci_dev, &sci_dev->rnc->remote_node_index);
+ scic, sci_dev, &sci_dev->rnc->remote_node_index);
if (status == SCI_SUCCESS) {
if (sci_dev->target_protocols.u.bits.attached_ssp_target) {
/**
*
- * @this_device: The remote device for which the suspend is being requested.
+ * @sci_dev: The remote device for which the suspend is being requested.
*
* This method invokes the remote device suspend state handler. enum sci_status
*/
enum sci_status scic_sds_remote_device_suspend(
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
u32 suspend_type)
{
- return this_device->state_handlers->suspend_handler(this_device, suspend_type);
+ return sci_dev->state_handlers->suspend_handler(sci_dev, suspend_type);
}
/**
*
- * @this_device: The remote device for which the resume is being requested.
+ * @sci_dev: The remote device for which the resume is being requested.
*
* This method invokes the remote device resume state handler. enum sci_status
*/
enum sci_status scic_sds_remote_device_resume(
- struct scic_sds_remote_device *this_device)
+ struct scic_sds_remote_device *sci_dev)
{
- return this_device->state_handlers->resume_handler(this_device);
+ return sci_dev->state_handlers->resume_handler(sci_dev);
}
/**
*
- * @this_device: The remote device for which the event handling is being
+ * @sci_dev: The remote device for which the event handling is being
* requested.
* @frame_index: This is the frame index that is being processed.
*
* enum sci_status
*/
enum sci_status scic_sds_remote_device_frame_handler(
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
u32 frame_index)
{
- return this_device->state_handlers->frame_handler(this_device, frame_index);
+ return sci_dev->state_handlers->frame_handler(sci_dev, frame_index);
}
/**
*
- * @this_device: The remote device for which the event handling is being
+ * @sci_dev: The remote device for which the event handling is being
* requested.
* @event_code: This is the event code that is to be processed.
*
* This method invokes the remote device event handler. enum sci_status
*/
enum sci_status scic_sds_remote_device_event_handler(
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
u32 event_code)
{
- return this_device->state_handlers->event_handler(this_device, event_code);
+ return sci_dev->state_handlers->event_handler(sci_dev, event_code);
}
/**
*
* @controller: The controller that is starting the io request.
- * @this_device: The remote device for which the start io handling is being
+ * @sci_dev: The remote device for which the start io handling is being
* requested.
* @io_request: The io request that is being started.
*
*/
enum sci_status scic_sds_remote_device_start_io(
struct scic_sds_controller *controller,
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
struct scic_sds_request *io_request)
{
- return this_device->state_handlers->start_io_handler(
- this_device, io_request);
+ return sci_dev->state_handlers->start_io_handler(
+ sci_dev, io_request);
}
/**
*
* @controller: The controller that is completing the io request.
- * @this_device: The remote device for which the complete io handling is being
+ * @sci_dev: The remote device for which the complete io handling is being
* requested.
* @io_request: The io request that is being completed.
*
*/
enum sci_status scic_sds_remote_device_complete_io(
struct scic_sds_controller *controller,
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
struct scic_sds_request *io_request)
{
- return this_device->state_handlers->complete_io_handler(
- this_device, io_request);
+ return sci_dev->state_handlers->complete_io_handler(
+ sci_dev, io_request);
}
/**
*
* @controller: The controller that is starting the task request.
- * @this_device: The remote device for which the start task handling is being
+ * @sci_dev: The remote device for which the start task handling is being
* requested.
* @io_request: The task request that is being started.
*
*/
enum sci_status scic_sds_remote_device_start_task(
struct scic_sds_controller *controller,
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
struct scic_sds_request *io_request)
{
- return this_device->state_handlers->start_task_handler(
- this_device, io_request);
+ return sci_dev->state_handlers->start_task_handler(
+ sci_dev, io_request);
}
/**
*
* @controller: The controller that is completing the task request.
- * @this_device: The remote device for which the complete task handling is
+ * @sci_dev: The remote device for which the complete task handling is
* being requested.
* @io_request: The task request that is being completed.
*
/**
*
- * @this_device:
+ * @sci_dev:
* @request:
*
* This method takes the request and bulids an appropriate SCU context for the
* request and then requests the controller to post the request. none
*/
void scic_sds_remote_device_post_request(
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
u32 request)
{
u32 context;
- context = scic_sds_remote_device_build_command_context(this_device, request);
+ context = scic_sds_remote_device_build_command_context(sci_dev, request);
scic_sds_controller_post_request(
- scic_sds_remote_device_get_controller(this_device),
+ scic_sds_remote_device_get_controller(sci_dev),
context
);
}
#if !defined(DISABLE_ATAPI)
/**
*
- * @this_device: The device to be checked.
+ * @sci_dev: The device to be checked.
*
* This method check the signature fis of a stp device to decide whether a
* device is atapi or not. true if a device is atapi device. False if a device
* is not atapi.
*/
bool scic_sds_remote_device_is_atapi(
- struct scic_sds_remote_device *this_device)
+ struct scic_sds_remote_device *sci_dev)
{
- if (!this_device->target_protocols.u.bits.attached_stp_target)
+ if (!sci_dev->target_protocols.u.bits.attached_stp_target)
return false;
- else if (this_device->is_direct_attached) {
+ else if (sci_dev->is_direct_attached) {
struct scic_sds_phy *phy;
struct scic_sata_phy_properties properties;
struct sata_fis_reg_d2h *signature_fis;
- phy = scic_sds_port_get_a_connected_phy(this_device->owning_port);
+ phy = scic_sds_port_get_a_connected_phy(sci_dev->owning_port);
scic_sata_phy_get_properties(phy, &properties);
/* decode the signature fis. */
static void scic_sds_remote_device_resume_complete_handler(
void *user_parameter)
{
- struct scic_sds_remote_device *this_device;
+ struct scic_sds_remote_device *sci_dev;
- this_device = (struct scic_sds_remote_device *)user_parameter;
+ sci_dev = (struct scic_sds_remote_device *)user_parameter;
if (
- sci_base_state_machine_get_state(&this_device->state_machine)
+ sci_base_state_machine_get_state(&sci_dev->state_machine)
!= SCI_BASE_REMOTE_DEVICE_STATE_READY
) {
sci_base_state_machine_change_state(
- &this_device->state_machine,
+ &sci_dev->state_machine,
SCI_BASE_REMOTE_DEVICE_STATE_READY
);
}
* requests and task requests of all types. none
*/
void scic_sds_remote_device_start_request(
- struct scic_sds_remote_device *this_device,
- struct scic_sds_request *the_request,
+ struct scic_sds_remote_device *sci_dev,
+ struct scic_sds_request *sci_req,
enum sci_status status)
{
/* We still have a fault in starting the io complete it on the port */
if (status == SCI_SUCCESS)
- scic_sds_remote_device_increment_request_count(this_device);
+ scic_sds_remote_device_increment_request_count(sci_dev);
else{
- this_device->owning_port->state_handlers->complete_io_handler(
- this_device->owning_port, this_device, the_request
+ sci_dev->owning_port->state_handlers->complete_io_handler(
+ sci_dev->owning_port, sci_dev, sci_req
);
}
}
/**
* This method will terminate all of the IO requests in the controllers IO
* request table that were targeted for this device.
- * @this_device: This parameter specifies the remote device for which to
+ * @sci_dev: This parameter specifies the remote device for which to
* attempt to terminate all requests.
*
* This method returns an indication as to whether all requests were
* this method will return the failure.
*/
static enum sci_status scic_sds_remote_device_terminate_requests(
- struct scic_sds_remote_device *this_device)
+ struct scic_sds_remote_device *sci_dev)
{
enum sci_status status = SCI_SUCCESS;
enum sci_status terminate_status = SCI_SUCCESS;
- struct scic_sds_request *the_request;
+ struct scic_sds_request *sci_req;
u32 index;
- u32 request_count = this_device->started_request_count;
+ u32 request_count = sci_dev->started_request_count;
for (index = 0;
(index < SCI_MAX_IO_REQUESTS) && (request_count > 0);
index++) {
- the_request = this_device->owning_port->owning_controller->io_request_table[index];
+ sci_req = sci_dev->owning_port->owning_controller->io_request_table[index];
- if ((the_request != NULL) && (the_request->target_device == this_device)) {
+ if ((sci_req != NULL) && (sci_req->target_device == sci_dev)) {
terminate_status = scic_controller_terminate_request(
- this_device->owning_port->owning_controller,
- this_device,
- the_request
+ sci_dev->owning_port->owning_controller,
+ sci_dev,
+ sci_req
);
if (terminate_status != SCI_SUCCESS)
* returns a failure. enum sci_status SCI_FAILURE_INVALID_STATE
*/
static enum sci_status scic_sds_remote_device_core_event_handler(
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
u32 event_code,
bool is_ready_state)
{
case SCU_EVENT_TYPE_RNC_OPS_MISC:
case SCU_EVENT_TYPE_RNC_SUSPEND_TX:
case SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX:
- status = scic_sds_remote_node_context_event_handler(this_device->rnc, event_code);
+ status = scic_sds_remote_node_context_event_handler(sci_dev->rnc, event_code);
break;
case SCU_EVENT_TYPE_PTX_SCHEDULE_EVENT:
status = SCI_SUCCESS;
/* Suspend the associated RNC */
- scic_sds_remote_node_context_suspend(this_device->rnc,
+ scic_sds_remote_node_context_suspend(sci_dev->rnc,
SCI_SOFTWARE_SUSPENSION,
NULL, NULL);
- dev_dbg(scirdev_to_dev(this_device),
+ dev_dbg(scirdev_to_dev(sci_dev),
"%s: device: %p event code: %x: %s\n",
- __func__, this_device, event_code,
+ __func__, sci_dev, event_code,
(is_ready_state)
? "I_T_Nexus_Timeout event"
: "I_T_Nexus_Timeout event in wrong state");
/* Else, fall through and treat as unhandled... */
default:
- dev_dbg(scirdev_to_dev(this_device),
+ dev_dbg(scirdev_to_dev(sci_dev),
"%s: device: %p event code: %x: %s\n",
- __func__, this_device, event_code,
+ __func__, sci_dev, event_code,
(is_ready_state)
? "unexpected event"
: "unexpected event in wrong state");
* returns a failure. enum sci_status SCI_FAILURE_INVALID_STATE
*/
static enum sci_status scic_sds_remote_device_default_event_handler(
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
u32 event_code)
{
- return scic_sds_remote_device_core_event_handler(this_device,
+ return scic_sds_remote_device_core_event_handler(sci_dev,
event_code,
false);
}
* SCI_FAILURE_INVALID_STATE
*/
enum sci_status scic_sds_remote_device_default_frame_handler(
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
u32 frame_index)
{
- dev_warn(scirdev_to_dev(this_device),
+ dev_warn(scirdev_to_dev(sci_dev),
"%s: SCIC Remote Device requested to handle frame %x "
"while in wrong state %d\n",
__func__,
frame_index,
sci_base_state_machine_get_state(
- &this_device->state_machine));
+ &sci_dev->state_machine));
/* Return the frame back to the controller */
scic_sds_controller_release_frame(
- scic_sds_remote_device_get_controller(this_device), frame_index
+ scic_sds_remote_device_get_controller(sci_dev), frame_index
);
return SCI_FAILURE_INVALID_STATE;
* unsolicited frame to that object. enum sci_status SCI_FAILURE_INVALID_STATE
*/
enum sci_status scic_sds_remote_device_general_frame_handler(
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
u32 frame_index)
{
enum sci_status result;
struct scic_sds_request *io_request;
result = scic_sds_unsolicited_frame_control_get_header(
- &(scic_sds_remote_device_get_controller(this_device)->uf_control),
+ &(scic_sds_remote_device_get_controller(sci_dev)->uf_control),
frame_index,
(void **)&frame_header
);
if (SCI_SUCCESS == result) {
io_request = scic_sds_controller_get_io_request_from_tag(
- scic_sds_remote_device_get_controller(this_device), frame_header->tag);
+ scic_sds_remote_device_get_controller(sci_dev), frame_header->tag);
if ((io_request == NULL)
- || (io_request->target_device != this_device)) {
+ || (io_request->target_device != sci_dev)) {
/*
* We could not map this tag to a valid IO request
* Just toss the frame and continue */
scic_sds_controller_release_frame(
- scic_sds_remote_device_get_controller(this_device), frame_index
+ scic_sds_remote_device_get_controller(sci_dev), frame_index
);
} else {
/* The IO request is now in charge of releasing the frame */
/**
*
- * @[in]: this_device This is the device object that is receiving the event.
+ * @[in]: sci_dev This is the device object that is receiving the event.
* @[in]: event_code The event code to process.
*
* This is a common method for handling events reported to the remote device
* from the controller object. enum sci_status
*/
enum sci_status scic_sds_remote_device_general_event_handler(
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
u32 event_code)
{
- return scic_sds_remote_device_core_event_handler(this_device,
+ return scic_sds_remote_device_core_event_handler(sci_dev,
event_code,
true);
}
/**
*
- * @this_device: The struct scic_sds_remote_device which is cast into a
+ * @sci_dev: The struct scic_sds_remote_device which is cast into a
* struct scic_sds_remote_device.
*
* This method will stop a struct scic_sds_remote_device that is already in the
static void scic_sds_remote_device_stopping_state_enter(
struct sci_base_object *object)
{
- struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)object;
+ struct scic_sds_remote_device *sci_dev = (struct scic_sds_remote_device *)object;
SET_STATE_HANDLER(
- this_device,
+ sci_dev,
scic_sds_remote_device_state_handler_table,
SCI_BASE_REMOTE_DEVICE_STATE_STOPPING
);
static void scic_sds_remote_device_failed_state_enter(
struct sci_base_object *object)
{
- struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)object;
+ struct scic_sds_remote_device *sci_dev = (struct scic_sds_remote_device *)object;
SET_STATE_HANDLER(
- this_device,
+ sci_dev,
scic_sds_remote_device_state_handler_table,
SCI_BASE_REMOTE_DEVICE_STATE_FAILED
);
static void scic_sds_remote_device_resetting_state_enter(
struct sci_base_object *object)
{
- struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)object;
+ struct scic_sds_remote_device *sci_dev = (struct scic_sds_remote_device *)object;
SET_STATE_HANDLER(
- this_device,
+ sci_dev,
scic_sds_remote_device_state_handler_table,
SCI_BASE_REMOTE_DEVICE_STATE_RESETTING
);
scic_sds_remote_node_context_suspend(
- this_device->rnc, SCI_SOFTWARE_SUSPENSION, NULL, NULL);
+ sci_dev->rnc, SCI_SOFTWARE_SUSPENSION, NULL, NULL);
}
/**
static void scic_sds_remote_device_resetting_state_exit(
struct sci_base_object *object)
{
- struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)object;
+ struct scic_sds_remote_device *sci_dev = (struct scic_sds_remote_device *)object;
- scic_sds_remote_node_context_resume(this_device->rnc, NULL, NULL);
+ scic_sds_remote_node_context_resume(sci_dev->rnc, NULL, NULL);
}
/**
static void scic_sds_remote_device_final_state_enter(
struct sci_base_object *object)
{
- struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)object;
+ struct scic_sds_remote_device *sci_dev = (struct scic_sds_remote_device *)object;
SET_STATE_HANDLER(
- this_device,
+ sci_dev,
scic_sds_remote_device_state_handler_table,
SCI_BASE_REMOTE_DEVICE_STATE_FINAL
);
enum sci_io_status);
typedef enum sci_status (*scic_sds_remote_device_handler_t)(
- struct scic_sds_remote_device *this_device);
+ struct scic_sds_remote_device *sci_dev);
typedef enum sci_status (*scic_sds_remote_device_suspend_handler_t)(
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
u32 suspend_type);
typedef enum sci_status (*scic_sds_remote_device_resume_handler_t)(
- struct scic_sds_remote_device *this_device);
+ struct scic_sds_remote_device *sci_dev);
typedef enum sci_status (*scic_sds_remote_device_frame_handler_t)(
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
u32 frame_index);
typedef enum sci_status (*scic_sds_remote_device_event_handler_t)(
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
u32 event_code);
typedef void (*scic_sds_remote_device_ready_not_ready_handler_t)(
- struct scic_sds_remote_device *this_device);
+ struct scic_sds_remote_device *sci_dev);
/**
* struct scic_sds_remote_device_state_handler - This structure conains the
*
* This macro incrments the request count for this device
*/
-#define scic_sds_remote_device_increment_request_count(this_device) \
- ((this_device)->started_request_count++)
+#define scic_sds_remote_device_increment_request_count(sci_dev) \
+ ((sci_dev)->started_request_count++)
/**
* scic_sds_remote_device_decrement_request_count() -
* This macro decrements the request count for this device. This count will
* never decrment past 0.
*/
-#define scic_sds_remote_device_decrement_request_count(this_device) \
- ((this_device)->started_request_count > 0 ? \
- (this_device)->started_request_count-- : 0)
+#define scic_sds_remote_device_decrement_request_count(sci_dev) \
+ ((sci_dev)->started_request_count > 0 ? \
+ (sci_dev)->started_request_count-- : 0)
/**
* scic_sds_remote_device_get_request_count() -
*
* This is a helper macro to return the current device request count.
*/
-#define scic_sds_remote_device_get_request_count(this_device) \
- ((this_device)->started_request_count)
+#define scic_sds_remote_device_get_request_count(sci_dev) \
+ ((sci_dev)->started_request_count)
/**
* scic_sds_remote_device_get_port() -
*
* This macro returns the owning port of this remote device obejct.
*/
-#define scic_sds_remote_device_get_port(this_device) \
- ((this_device)->owning_port)
+#define scic_sds_remote_device_get_port(sci_dev) \
+ ((sci_dev)->owning_port)
/**
* scic_sds_remote_device_get_controller() -
*
* This macro returns the controller object that contains this device object
*/
-#define scic_sds_remote_device_get_controller(this_device) \
- scic_sds_port_get_controller(scic_sds_remote_device_get_port(this_device))
+#define scic_sds_remote_device_get_controller(sci_dev) \
+ scic_sds_port_get_controller(scic_sds_remote_device_get_port(sci_dev))
/**
* scic_sds_remote_device_set_state_handlers() -
* This macro sets the remote device state handlers pointer and is set on entry
* to each device state.
*/
-#define scic_sds_remote_device_set_state_handlers(this_device, handlers) \
- ((this_device)->state_handlers = (handlers))
+#define scic_sds_remote_device_set_state_handlers(sci_dev, handlers) \
+ ((sci_dev)->state_handlers = (handlers))
/**
* scic_sds_remote_device_get_port() -
*
* This macro returns the owning port of this device
*/
-#define scic_sds_remote_device_get_port(this_device) \
- ((this_device)->owning_port)
+#define scic_sds_remote_device_get_port(sci_dev) \
+ ((sci_dev)->owning_port)
/**
* scic_sds_remote_device_get_sequence() -
*
* This macro returns the remote device sequence value
*/
-#define scic_sds_remote_device_get_sequence(this_device) \
+#define scic_sds_remote_device_get_sequence(sci_dev) \
(\
- scic_sds_remote_device_get_controller(this_device)-> \
- remote_device_sequence[(this_device)->rnc->remote_node_index] \
+ scic_sds_remote_device_get_controller(sci_dev)-> \
+ remote_device_sequence[(sci_dev)->rnc->remote_node_index] \
)
/**
*
* This macro returns the controllers protocol engine group
*/
-#define scic_sds_remote_device_get_controller_peg(this_device) \
+#define scic_sds_remote_device_get_controller_peg(sci_dev) \
(\
scic_sds_controller_get_protocol_engine_group(\
scic_sds_port_get_controller(\
- scic_sds_remote_device_get_port(this_device) \
+ scic_sds_remote_device_get_port(sci_dev) \
) \
) \
)
*
* This macro returns the port index for the devices owning port
*/
-#define scic_sds_remote_device_get_port_index(this_device) \
- (scic_sds_port_get_index(scic_sds_remote_device_get_port(this_device)))
+#define scic_sds_remote_device_get_port_index(sci_dev) \
+ (scic_sds_port_get_index(scic_sds_remote_device_get_port(sci_dev)))
/**
* scic_sds_remote_device_get_index() -
*
* This macro returns the remote node index for this device object
*/
-#define scic_sds_remote_device_get_index(this_device) \
- ((this_device)->rnc->remote_node_index)
+#define scic_sds_remote_device_get_index(sci_dev) \
+ ((sci_dev)->rnc->remote_node_index)
/**
* scic_sds_remote_device_build_command_context() -
((device)->working_request = (request))
enum sci_status scic_sds_remote_device_frame_handler(
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
u32 frame_index);
enum sci_status scic_sds_remote_device_event_handler(
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
u32 event_code);
enum sci_status scic_sds_remote_device_start_io(
struct scic_sds_controller *controller,
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
struct scic_sds_request *io_request);
enum sci_status scic_sds_remote_device_complete_io(
struct scic_sds_controller *controller,
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
struct scic_sds_request *io_request);
enum sci_status scic_sds_remote_device_resume(
- struct scic_sds_remote_device *this_device);
+ struct scic_sds_remote_device *sci_dev);
enum sci_status scic_sds_remote_device_suspend(
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
u32 suspend_type);
enum sci_status scic_sds_remote_device_start_task(
struct scic_sds_controller *controller,
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
struct scic_sds_request *io_request);
void scic_sds_remote_device_post_request(
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
u32 request);
#if !defined(DISABLE_ATAPI)
bool scic_sds_remote_device_is_atapi(
- struct scic_sds_remote_device *this_device);
+ struct scic_sds_remote_device *sci_dev);
#else /* !defined(DISABLE_ATAPI) */
-#define scic_sds_remote_device_is_atapi(this_device) false
+#define scic_sds_remote_device_is_atapi(sci_dev) false
#endif /* !defined(DISABLE_ATAPI) */
void scic_sds_remote_device_start_request(
- struct scic_sds_remote_device *this_device,
- struct scic_sds_request *the_request,
+ struct scic_sds_remote_device *sci_dev,
+ struct scic_sds_request *sci_req,
enum sci_status status);
void scic_sds_remote_device_continue_request(void *sci_dev);
enum sci_status scic_sds_remote_device_default_start_handler(
- struct scic_sds_remote_device *this_device);
+ struct scic_sds_remote_device *sci_dev);
enum sci_status scic_sds_remote_device_default_fail_handler(
- struct scic_sds_remote_device *this_device);
+ struct scic_sds_remote_device *sci_dev);
enum sci_status scic_sds_remote_device_default_destruct_handler(
- struct scic_sds_remote_device *this_device);
+ struct scic_sds_remote_device *sci_dev);
enum sci_status scic_sds_remote_device_default_reset_handler(
struct scic_sds_remote_device *device);
struct scic_sds_request *request);
enum sci_status scic_sds_remote_device_default_suspend_handler(
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
u32 suspend_type);
enum sci_status scic_sds_remote_device_default_resume_handler(
- struct scic_sds_remote_device *this_device);
+ struct scic_sds_remote_device *sci_dev);
enum sci_status scic_sds_remote_device_default_frame_handler(
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
u32 frame_index);
enum sci_status scic_sds_remote_device_ready_state_stop_handler(
struct scic_sds_remote_device *device);
enum sci_status scic_sds_remote_device_general_frame_handler(
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
u32 frame_index);
enum sci_status scic_sds_remote_device_general_event_handler(
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
u32 event_code);
enum sci_status scic_sds_ssp_remote_device_ready_suspended_substate_resume_handler(
- struct scic_sds_remote_device *this_device);
+ struct scic_sds_remote_device *sci_dev);
#endif /* _SCIC_SDS_REMOTE_DEVICE_H_ */
/**
*
- * @this_rnc: The RNC for which the is posted request is being made.
+ * @sci_rnc: The RNC for which the is posted request is being made.
*
* This method will return true if the RNC is not in the initial state. In all
* other states the RNC is considered active and this will return true. The
/**
*
- * @this_rnc: The state of the remote node context object to check.
+ * @sci_rnc: The state of the remote node context object to check.
*
* This method will return true if the remote node context is in a READY state
* otherwise it will return false bool true if the remote node context is in
* the ready state. false if the remote node context is not in the ready state.
*/
bool scic_sds_remote_node_context_is_ready(
- struct scic_sds_remote_node_context *this_rnc)
+ struct scic_sds_remote_node_context *sci_rnc)
{
- u32 current_state = sci_base_state_machine_get_state(&this_rnc->state_machine);
+ u32 current_state = sci_base_state_machine_get_state(&sci_rnc->state_machine);
if (current_state == SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE) {
return true;
/**
*
- * @this_device: The remote device to use to construct the RNC buffer.
+ * @sci_dev: The remote device to use to construct the RNC buffer.
* @rnc: The buffer into which the remote device data will be copied.
*
* This method will construct the RNC buffer for this remote device object. none
*/
static void scic_sds_remote_node_context_construct_buffer(
- struct scic_sds_remote_node_context *this_rnc)
+ struct scic_sds_remote_node_context *sci_rnc)
{
union scu_remote_node_context *rnc;
- struct scic_sds_controller *the_controller;
+ struct scic_sds_controller *scic;
- the_controller = scic_sds_remote_device_get_controller(this_rnc->device);
+ scic = scic_sds_remote_device_get_controller(sci_rnc->device);
rnc = scic_sds_controller_get_remote_node_context_buffer(
- the_controller, this_rnc->remote_node_index);
+ scic, sci_rnc->remote_node_index);
memset(
rnc,
0x00,
sizeof(union scu_remote_node_context)
- * scic_sds_remote_device_node_count(this_rnc->device)
+ * scic_sds_remote_device_node_count(sci_rnc->device)
);
- rnc->ssp.remote_node_index = this_rnc->remote_node_index;
- rnc->ssp.remote_node_port_width = this_rnc->device->device_port_width;
+ rnc->ssp.remote_node_index = sci_rnc->remote_node_index;
+ rnc->ssp.remote_node_port_width = sci_rnc->device->device_port_width;
rnc->ssp.logical_port_index =
- scic_sds_remote_device_get_port_index(this_rnc->device);
+ scic_sds_remote_device_get_port_index(sci_rnc->device);
- rnc->ssp.remote_sas_address_hi = SCIC_SWAP_DWORD(this_rnc->device->device_address.high);
- rnc->ssp.remote_sas_address_lo = SCIC_SWAP_DWORD(this_rnc->device->device_address.low);
+ rnc->ssp.remote_sas_address_hi = SCIC_SWAP_DWORD(sci_rnc->device->device_address.high);
+ rnc->ssp.remote_sas_address_lo = SCIC_SWAP_DWORD(sci_rnc->device->device_address.low);
rnc->ssp.nexus_loss_timer_enable = true;
rnc->ssp.check_bit = false;
if (
- this_rnc->device->target_protocols.u.bits.attached_sata_device
- || this_rnc->device->target_protocols.u.bits.attached_stp_target
+ sci_rnc->device->target_protocols.u.bits.attached_sata_device
+ || sci_rnc->device->target_protocols.u.bits.attached_stp_target
) {
rnc->ssp.connection_occupancy_timeout =
- the_controller->user_parameters.sds1.stp_max_occupancy_timeout;
+ scic->user_parameters.sds1.stp_max_occupancy_timeout;
rnc->ssp.connection_inactivity_timeout =
- the_controller->user_parameters.sds1.stp_inactivity_timeout;
+ scic->user_parameters.sds1.stp_inactivity_timeout;
} else {
rnc->ssp.connection_occupancy_timeout =
- the_controller->user_parameters.sds1.ssp_max_occupancy_timeout;
+ scic->user_parameters.sds1.ssp_max_occupancy_timeout;
rnc->ssp.connection_inactivity_timeout =
- the_controller->user_parameters.sds1.ssp_inactivity_timeout;
+ scic->user_parameters.sds1.ssp_inactivity_timeout;
}
rnc->ssp.initial_arbitration_wait_time = 0;
/* Open Address Frame Parameters */
- rnc->ssp.oaf_connection_rate = this_rnc->device->connection_rate;
+ rnc->ssp.oaf_connection_rate = sci_rnc->device->connection_rate;
rnc->ssp.oaf_features = 0;
rnc->ssp.oaf_source_zone_group = 0;
rnc->ssp.oaf_more_compatibility_features = 0;
/**
*
- * @this_rnc:
- * @the_callback:
+ * @sci_rnc:
+ * @callback:
* @callback_parameter:
*
* This method will setup the remote node context object so it will transition
* transition to its final state then this function does nothing. none
*/
static void scic_sds_remote_node_context_setup_to_resume(
- struct scic_sds_remote_node_context *this_rnc,
- scics_sds_remote_node_context_callback the_callback,
+ struct scic_sds_remote_node_context *sci_rnc,
+ scics_sds_remote_node_context_callback callback,
void *callback_parameter)
{
- if (this_rnc->destination_state != SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_FINAL) {
- this_rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_READY;
- this_rnc->user_callback = the_callback;
- this_rnc->user_cookie = callback_parameter;
+ if (sci_rnc->destination_state != SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_FINAL) {
+ sci_rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_READY;
+ sci_rnc->user_callback = callback;
+ sci_rnc->user_cookie = callback_parameter;
}
}
/**
*
- * @this_rnc:
- * @the_callback:
+ * @sci_rnc:
+ * @callback:
* @callback_parameter:
*
* This method will setup the remote node context object so it will transistion
* to its final state. none
*/
static void scic_sds_remote_node_context_setup_to_destory(
- struct scic_sds_remote_node_context *this_rnc,
- scics_sds_remote_node_context_callback the_callback,
+ struct scic_sds_remote_node_context *sci_rnc,
+ scics_sds_remote_node_context_callback callback,
void *callback_parameter)
{
- this_rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_FINAL;
- this_rnc->user_callback = the_callback;
- this_rnc->user_cookie = callback_parameter;
+ sci_rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_FINAL;
+ sci_rnc->user_callback = callback;
+ sci_rnc->user_cookie = callback_parameter;
}
/**
*
- * @this_rnc:
- * @the_callback:
+ * @sci_rnc:
+ * @callback:
*
* This method will continue to resume a remote node context. This is used in
* the states where a resume is requested while a resume is in progress.
*/
static enum sci_status scic_sds_remote_node_context_continue_to_resume_handler(
- struct scic_sds_remote_node_context *this_rnc,
- scics_sds_remote_node_context_callback the_callback,
+ struct scic_sds_remote_node_context *sci_rnc,
+ scics_sds_remote_node_context_callback callback,
void *callback_parameter)
{
- if (this_rnc->destination_state == SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_READY) {
- this_rnc->user_callback = the_callback;
- this_rnc->user_cookie = callback_parameter;
+ if (sci_rnc->destination_state == SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_READY) {
+ sci_rnc->user_callback = callback;
+ sci_rnc->user_cookie = callback_parameter;
return SCI_SUCCESS;
}
/* --------------------------------------------------------------------------- */
static enum sci_status scic_sds_remote_node_context_default_destruct_handler(
- struct scic_sds_remote_node_context *this_rnc,
- scics_sds_remote_node_context_callback the_callback,
+ struct scic_sds_remote_node_context *sci_rnc,
+ scics_sds_remote_node_context_callback callback,
void *callback_parameter)
{
- dev_warn(scirdev_to_dev(this_rnc->device),
+ dev_warn(scirdev_to_dev(sci_rnc->device),
"%s: SCIC Remote Node Context 0x%p requested to stop while "
"in unexpected state %d\n",
__func__,
- this_rnc,
- sci_base_state_machine_get_state(&this_rnc->state_machine));
+ sci_rnc,
+ sci_base_state_machine_get_state(&sci_rnc->state_machine));
/*
* We have decided that the destruct request on the remote node context can not fail
}
static enum sci_status scic_sds_remote_node_context_default_suspend_handler(
- struct scic_sds_remote_node_context *this_rnc,
+ struct scic_sds_remote_node_context *sci_rnc,
u32 suspend_type,
- scics_sds_remote_node_context_callback the_callback,
+ scics_sds_remote_node_context_callback callback,
void *callback_parameter)
{
- dev_warn(scirdev_to_dev(this_rnc->device),
+ dev_warn(scirdev_to_dev(sci_rnc->device),
"%s: SCIC Remote Node Context 0x%p requested to suspend "
"while in wrong state %d\n",
__func__,
- this_rnc,
- sci_base_state_machine_get_state(&this_rnc->state_machine));
+ sci_rnc,
+ sci_base_state_machine_get_state(&sci_rnc->state_machine));
return SCI_FAILURE_INVALID_STATE;
}
static enum sci_status scic_sds_remote_node_context_default_resume_handler(
- struct scic_sds_remote_node_context *this_rnc,
- scics_sds_remote_node_context_callback the_callback,
+ struct scic_sds_remote_node_context *sci_rnc,
+ scics_sds_remote_node_context_callback callback,
void *callback_parameter)
{
- dev_warn(scirdev_to_dev(this_rnc->device),
+ dev_warn(scirdev_to_dev(sci_rnc->device),
"%s: SCIC Remote Node Context 0x%p requested to resume "
"while in wrong state %d\n",
__func__,
- this_rnc,
- sci_base_state_machine_get_state(&this_rnc->state_machine));
+ sci_rnc,
+ sci_base_state_machine_get_state(&sci_rnc->state_machine));
return SCI_FAILURE_INVALID_STATE;
}
static enum sci_status scic_sds_remote_node_context_default_start_io_handler(
- struct scic_sds_remote_node_context *this_rnc,
- struct scic_sds_request *the_request)
+ struct scic_sds_remote_node_context *sci_rnc,
+ struct scic_sds_request *sci_req)
{
- dev_warn(scirdev_to_dev(this_rnc->device),
+ dev_warn(scirdev_to_dev(sci_rnc->device),
"%s: SCIC Remote Node Context 0x%p requested to start io "
"0x%p while in wrong state %d\n",
__func__,
- this_rnc,
- the_request,
- sci_base_state_machine_get_state(&this_rnc->state_machine));
+ sci_rnc,
+ sci_req,
+ sci_base_state_machine_get_state(&sci_rnc->state_machine));
return SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
}
static enum sci_status scic_sds_remote_node_context_default_start_task_handler(
- struct scic_sds_remote_node_context *this_rnc,
- struct scic_sds_request *the_request)
+ struct scic_sds_remote_node_context *sci_rnc,
+ struct scic_sds_request *sci_req)
{
- dev_warn(scirdev_to_dev(this_rnc->device),
+ dev_warn(scirdev_to_dev(sci_rnc->device),
"%s: SCIC Remote Node Context 0x%p requested to start "
"task 0x%p while in wrong state %d\n",
__func__,
- this_rnc,
- the_request,
- sci_base_state_machine_get_state(&this_rnc->state_machine));
+ sci_rnc,
+ sci_req,
+ sci_base_state_machine_get_state(&sci_rnc->state_machine));
return SCI_FAILURE;
}
static enum sci_status scic_sds_remote_node_context_default_event_handler(
- struct scic_sds_remote_node_context *this_rnc,
+ struct scic_sds_remote_node_context *sci_rnc,
u32 event_code)
{
- dev_warn(scirdev_to_dev(this_rnc->device),
+ dev_warn(scirdev_to_dev(sci_rnc->device),
"%s: SCIC Remote Node Context 0x%p requested to process "
"event 0x%x while in wrong state %d\n",
__func__,
- this_rnc,
+ sci_rnc,
event_code,
- sci_base_state_machine_get_state(&this_rnc->state_machine));
+ sci_base_state_machine_get_state(&sci_rnc->state_machine));
return SCI_FAILURE_INVALID_STATE;
}
/**
*
- * @this_rnc: The rnc for which the task request is targeted.
- * @the_request: The request which is going to be started.
+ * @sci_rnc: The rnc for which the task request is targeted.
+ * @sci_req: The request which is going to be started.
*
* This method determines if the task request can be started by the SCU
* hardware. When the RNC is in the ready state any task can be started.
* enum sci_status SCI_SUCCESS
*/
static enum sci_status scic_sds_remote_node_context_success_start_task_handler(
- struct scic_sds_remote_node_context *this_rnc,
- struct scic_sds_request *the_request)
+ struct scic_sds_remote_node_context *sci_rnc,
+ struct scic_sds_request *sci_req)
{
return SCI_SUCCESS;
}
/**
*
- * @this_rnc:
- * @the_callback:
+ * @sci_rnc:
+ * @callback:
* @callback_parameter:
*
* This method handles destruct calls from the various state handlers. The
* callback. enum sci_status
*/
static enum sci_status scic_sds_remote_node_context_general_destruct_handler(
- struct scic_sds_remote_node_context *this_rnc,
- scics_sds_remote_node_context_callback the_callback,
+ struct scic_sds_remote_node_context *sci_rnc,
+ scics_sds_remote_node_context_callback callback,
void *callback_parameter)
{
scic_sds_remote_node_context_setup_to_destory(
- this_rnc, the_callback, callback_parameter
+ sci_rnc, callback, callback_parameter
);
sci_base_state_machine_change_state(
- &this_rnc->state_machine,
+ &sci_rnc->state_machine,
SCIC_SDS_REMOTE_NODE_CONTEXT_INVALIDATING_STATE
);
/* --------------------------------------------------------------------------- */
static enum sci_status scic_sds_remote_node_context_initial_state_resume_handler(
- struct scic_sds_remote_node_context *this_rnc,
- scics_sds_remote_node_context_callback the_callback,
+ struct scic_sds_remote_node_context *sci_rnc,
+ scics_sds_remote_node_context_callback callback,
void *callback_parameter)
{
- if (this_rnc->remote_node_index != SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX) {
+ if (sci_rnc->remote_node_index != SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX) {
scic_sds_remote_node_context_setup_to_resume(
- this_rnc, the_callback, callback_parameter
+ sci_rnc, callback, callback_parameter
);
- scic_sds_remote_node_context_construct_buffer(this_rnc);
+ scic_sds_remote_node_context_construct_buffer(sci_rnc);
sci_base_state_machine_change_state(
- &this_rnc->state_machine,
+ &sci_rnc->state_machine,
SCIC_SDS_REMOTE_NODE_CONTEXT_POSTING_STATE
);
/* --------------------------------------------------------------------------- */
static enum sci_status scic_sds_remote_node_context_posting_state_event_handler(
- struct scic_sds_remote_node_context *this_rnc,
+ struct scic_sds_remote_node_context *sci_rnc,
u32 event_code)
{
enum sci_status status;
status = SCI_SUCCESS;
sci_base_state_machine_change_state(
- &this_rnc->state_machine,
+ &sci_rnc->state_machine,
SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE
);
break;
default:
status = SCI_FAILURE;
- dev_warn(scirdev_to_dev(this_rnc->device),
+ dev_warn(scirdev_to_dev(sci_rnc->device),
"%s: SCIC Remote Node Context 0x%p requested to "
"process unexpected event 0x%x while in posting "
"state\n",
__func__,
- this_rnc,
+ sci_rnc,
event_code);
break;
}
/* --------------------------------------------------------------------------- */
static enum sci_status scic_sds_remote_node_context_invalidating_state_destruct_handler(
- struct scic_sds_remote_node_context *this_rnc,
- scics_sds_remote_node_context_callback the_callback,
+ struct scic_sds_remote_node_context *sci_rnc,
+ scics_sds_remote_node_context_callback callback,
void *callback_parameter)
{
scic_sds_remote_node_context_setup_to_destory(
- this_rnc, the_callback, callback_parameter
+ sci_rnc, callback, callback_parameter
);
return SCI_SUCCESS;
}
static enum sci_status scic_sds_remote_node_context_invalidating_state_event_handler(
- struct scic_sds_remote_node_context *this_rnc,
+ struct scic_sds_remote_node_context *sci_rnc,
u32 event_code)
{
enum sci_status status;
if (scu_get_event_code(event_code) == SCU_EVENT_POST_RNC_INVALIDATE_COMPLETE) {
status = SCI_SUCCESS;
- if (this_rnc->destination_state == SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_FINAL) {
+ if (sci_rnc->destination_state == SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_FINAL) {
sci_base_state_machine_change_state(
- &this_rnc->state_machine,
+ &sci_rnc->state_machine,
SCIC_SDS_REMOTE_NODE_CONTEXT_INITIAL_STATE
);
} else {
sci_base_state_machine_change_state(
- &this_rnc->state_machine,
+ &sci_rnc->state_machine,
SCIC_SDS_REMOTE_NODE_CONTEXT_POSTING_STATE
);
}
/*
* We really dont care if the hardware is going to suspend
* the device since it's being invalidated anyway */
- dev_dbg(scirdev_to_dev(this_rnc->device),
+ dev_dbg(scirdev_to_dev(sci_rnc->device),
"%s: SCIC Remote Node Context 0x%p was "
"suspeneded by hardware while being "
"invalidated.\n",
__func__,
- this_rnc);
+ sci_rnc);
status = SCI_SUCCESS;
break;
default:
- dev_warn(scirdev_to_dev(this_rnc->device),
+ dev_warn(scirdev_to_dev(sci_rnc->device),
"%s: SCIC Remote Node Context 0x%p "
"requested to process event 0x%x while "
"in state %d.\n",
__func__,
- this_rnc,
+ sci_rnc,
event_code,
sci_base_state_machine_get_state(
- &this_rnc->state_machine));
+ &sci_rnc->state_machine));
status = SCI_FAILURE;
break;
}
static enum sci_status scic_sds_remote_node_context_resuming_state_event_handler(
- struct scic_sds_remote_node_context *this_rnc,
+ struct scic_sds_remote_node_context *sci_rnc,
u32 event_code)
{
enum sci_status status;
status = SCI_SUCCESS;
sci_base_state_machine_change_state(
- &this_rnc->state_machine,
+ &sci_rnc->state_machine,
SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE
);
} else {
/*
* We really dont care if the hardware is going to suspend
* the device since it's being resumed anyway */
- dev_dbg(scirdev_to_dev(this_rnc->device),
+ dev_dbg(scirdev_to_dev(sci_rnc->device),
"%s: SCIC Remote Node Context 0x%p was "
"suspeneded by hardware while being resumed.\n",
__func__,
- this_rnc);
+ sci_rnc);
status = SCI_SUCCESS;
break;
default:
- dev_warn(scirdev_to_dev(this_rnc->device),
+ dev_warn(scirdev_to_dev(sci_rnc->device),
"%s: SCIC Remote Node Context 0x%p requested "
"to process event 0x%x while in state %d.\n",
__func__,
- this_rnc,
+ sci_rnc,
event_code,
sci_base_state_machine_get_state(
- &this_rnc->state_machine));
+ &sci_rnc->state_machine));
status = SCI_FAILURE;
break;
}
/**
*
- * @this_rnc: The remote node context object being suspended.
- * @the_callback: The callback when the suspension is complete.
+ * @sci_rnc: The remote node context object being suspended.
+ * @callback: The callback when the suspension is complete.
* @callback_parameter: The parameter that is to be passed into the callback.
*
* This method will handle the suspend requests from the ready state.
* SCI_SUCCESS
*/
static enum sci_status scic_sds_remote_node_context_ready_state_suspend_handler(
- struct scic_sds_remote_node_context *this_rnc,
+ struct scic_sds_remote_node_context *sci_rnc,
u32 suspend_type,
- scics_sds_remote_node_context_callback the_callback,
+ scics_sds_remote_node_context_callback callback,
void *callback_parameter)
{
- this_rnc->user_callback = the_callback;
- this_rnc->user_cookie = callback_parameter;
- this_rnc->suspension_code = suspend_type;
+ sci_rnc->user_callback = callback;
+ sci_rnc->user_cookie = callback_parameter;
+ sci_rnc->suspension_code = suspend_type;
if (suspend_type == SCI_SOFTWARE_SUSPENSION) {
scic_sds_remote_device_post_request(
- this_rnc->device,
+ sci_rnc->device,
SCU_CONTEXT_COMMAND_POST_RNC_SUSPEND_TX
);
}
sci_base_state_machine_change_state(
- &this_rnc->state_machine,
+ &sci_rnc->state_machine,
SCIC_SDS_REMOTE_NODE_CONTEXT_AWAIT_SUSPENSION_STATE
);
/**
*
- * @this_rnc: The rnc for which the io request is targeted.
- * @the_request: The request which is going to be started.
+ * @sci_rnc: The rnc for which the io request is targeted.
+ * @sci_req: The request which is going to be started.
*
* This method determines if the io request can be started by the SCU hardware.
* When the RNC is in the ready state any io request can be started. enum sci_status
* SCI_SUCCESS
*/
static enum sci_status scic_sds_remote_node_context_ready_state_start_io_handler(
- struct scic_sds_remote_node_context *this_rnc,
- struct scic_sds_request *the_request)
+ struct scic_sds_remote_node_context *sci_rnc,
+ struct scic_sds_request *sci_req)
{
return SCI_SUCCESS;
}
static enum sci_status scic_sds_remote_node_context_ready_state_event_handler(
- struct scic_sds_remote_node_context *this_rnc,
+ struct scic_sds_remote_node_context *sci_rnc,
u32 event_code)
{
enum sci_status status;
switch (scu_get_event_type(event_code)) {
case SCU_EVENT_TL_RNC_SUSPEND_TX:
sci_base_state_machine_change_state(
- &this_rnc->state_machine,
+ &sci_rnc->state_machine,
SCIC_SDS_REMOTE_NODE_CONTEXT_TX_SUSPENDED_STATE
);
- this_rnc->suspension_code = scu_get_event_specifier(event_code);
+ sci_rnc->suspension_code = scu_get_event_specifier(event_code);
status = SCI_SUCCESS;
break;
case SCU_EVENT_TL_RNC_SUSPEND_TX_RX:
sci_base_state_machine_change_state(
- &this_rnc->state_machine,
+ &sci_rnc->state_machine,
SCIC_SDS_REMOTE_NODE_CONTEXT_TX_RX_SUSPENDED_STATE
);
- this_rnc->suspension_code = scu_get_event_specifier(event_code);
+ sci_rnc->suspension_code = scu_get_event_specifier(event_code);
status = SCI_SUCCESS;
break;
default:
- dev_warn(scirdev_to_dev(this_rnc->device),
+ dev_warn(scirdev_to_dev(sci_rnc->device),
"%s: SCIC Remote Node Context 0x%p requested to "
"process event 0x%x while in state %d.\n",
__func__,
- this_rnc,
+ sci_rnc,
event_code,
sci_base_state_machine_get_state(
- &this_rnc->state_machine));
+ &sci_rnc->state_machine));
status = SCI_FAILURE;
break;
/* --------------------------------------------------------------------------- */
static enum sci_status scic_sds_remote_node_context_tx_suspended_state_resume_handler(
- struct scic_sds_remote_node_context *this_rnc,
- scics_sds_remote_node_context_callback the_callback,
+ struct scic_sds_remote_node_context *sci_rnc,
+ scics_sds_remote_node_context_callback callback,
void *callback_parameter)
{
enum sci_status status;
struct smp_discover_response_protocols protocols;
scic_sds_remote_node_context_setup_to_resume(
- this_rnc, the_callback, callback_parameter
+ sci_rnc, callback, callback_parameter
);
/* TODO: consider adding a resume action of NONE, INVALIDATE, WRITE_TLCR */
- scic_remote_device_get_protocols(this_rnc->device, &protocols);
+ scic_remote_device_get_protocols(sci_rnc->device, &protocols);
if (
(protocols.u.bits.attached_ssp_target == 1)
|| (protocols.u.bits.attached_smp_target == 1)
) {
sci_base_state_machine_change_state(
- &this_rnc->state_machine,
+ &sci_rnc->state_machine,
SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE
);
status = SCI_SUCCESS;
} else if (protocols.u.bits.attached_stp_target == 1) {
- if (this_rnc->device->is_direct_attached) {
+ if (sci_rnc->device->is_direct_attached) {
/* @todo Fix this since I am being silly in writing to the STPTLDARNI register. */
sci_base_state_machine_change_state(
- &this_rnc->state_machine,
+ &sci_rnc->state_machine,
SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE
);
} else {
sci_base_state_machine_change_state(
- &this_rnc->state_machine,
+ &sci_rnc->state_machine,
SCIC_SDS_REMOTE_NODE_CONTEXT_INVALIDATING_STATE
);
}
/**
*
- * @this_rnc: The remote node context which is to receive the task request.
- * @the_request: The task request to be transmitted to to the remote target
+ * @sci_rnc: The remote node context which is to receive the task request.
+ * @sci_req: The task request to be transmitted to to the remote target
* device.
*
* This method will report a success or failure attempt to start a new task
* enum sci_status SCI_SUCCESS
*/
static enum sci_status scic_sds_remote_node_context_suspended_start_task_handler(
- struct scic_sds_remote_node_context *this_rnc,
- struct scic_sds_request *the_request)
+ struct scic_sds_remote_node_context *sci_rnc,
+ struct scic_sds_request *sci_req)
{
- scic_sds_remote_node_context_resume(this_rnc, NULL, NULL);
+ scic_sds_remote_node_context_resume(sci_rnc, NULL, NULL);
return SCI_SUCCESS;
}
/* --------------------------------------------------------------------------- */
static enum sci_status scic_sds_remote_node_context_tx_rx_suspended_state_resume_handler(
- struct scic_sds_remote_node_context *this_rnc,
- scics_sds_remote_node_context_callback the_callback,
+ struct scic_sds_remote_node_context *sci_rnc,
+ scics_sds_remote_node_context_callback callback,
void *callback_parameter)
{
scic_sds_remote_node_context_setup_to_resume(
- this_rnc, the_callback, callback_parameter
+ sci_rnc, callback, callback_parameter
);
sci_base_state_machine_change_state(
- &this_rnc->state_machine,
+ &sci_rnc->state_machine,
SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE
);
*
*/
static enum sci_status scic_sds_remote_node_context_await_suspension_state_resume_handler(
- struct scic_sds_remote_node_context *this_rnc,
- scics_sds_remote_node_context_callback the_callback,
+ struct scic_sds_remote_node_context *sci_rnc,
+ scics_sds_remote_node_context_callback callback,
void *callback_parameter)
{
scic_sds_remote_node_context_setup_to_resume(
- this_rnc, the_callback, callback_parameter
+ sci_rnc, callback, callback_parameter
);
return SCI_SUCCESS;
/**
*
- * @this_rnc: The remote node context which is to receive the task request.
- * @the_request: The task request to be transmitted to to the remote target
+ * @sci_rnc: The remote node context which is to receive the task request.
+ * @sci_req: The task request to be transmitted to to the remote target
* device.
*
* This method will report a success or failure attempt to start a new task
* enum sci_status SCI_SUCCESS
*/
static enum sci_status scic_sds_remote_node_context_await_suspension_state_start_task_handler(
- struct scic_sds_remote_node_context *this_rnc,
- struct scic_sds_request *the_request)
+ struct scic_sds_remote_node_context *sci_rnc,
+ struct scic_sds_request *sci_req)
{
return SCI_SUCCESS;
}
static enum sci_status scic_sds_remote_node_context_await_suspension_state_event_handler(
- struct scic_sds_remote_node_context *this_rnc,
+ struct scic_sds_remote_node_context *sci_rnc,
u32 event_code)
{
enum sci_status status;
switch (scu_get_event_type(event_code)) {
case SCU_EVENT_TL_RNC_SUSPEND_TX:
sci_base_state_machine_change_state(
- &this_rnc->state_machine,
+ &sci_rnc->state_machine,
SCIC_SDS_REMOTE_NODE_CONTEXT_TX_SUSPENDED_STATE
);
- this_rnc->suspension_code = scu_get_event_specifier(event_code);
+ sci_rnc->suspension_code = scu_get_event_specifier(event_code);
status = SCI_SUCCESS;
break;
case SCU_EVENT_TL_RNC_SUSPEND_TX_RX:
sci_base_state_machine_change_state(
- &this_rnc->state_machine,
+ &sci_rnc->state_machine,
SCIC_SDS_REMOTE_NODE_CONTEXT_TX_RX_SUSPENDED_STATE
);
- this_rnc->suspension_code = scu_get_event_specifier(event_code);
+ sci_rnc->suspension_code = scu_get_event_specifier(event_code);
status = SCI_SUCCESS;
break;
default:
- dev_warn(scirdev_to_dev(this_rnc->device),
+ dev_warn(scirdev_to_dev(sci_rnc->device),
"%s: SCIC Remote Node Context 0x%p requested to "
"process event 0x%x while in state %d.\n",
__func__,
- this_rnc,
+ sci_rnc,
event_code,
sci_base_state_machine_get_state(
- &this_rnc->state_machine));
+ &sci_rnc->state_machine));
status = SCI_FAILURE;
break;
/**
*
- * @this_rnc: The remote node context object that is to be validated.
+ * @sci_rnc: The remote node context object that is to be validated.
*
* This method will mark the rnc buffer as being valid and post the request to
* the hardware. none
*/
static void scic_sds_remote_node_context_validate_context_buffer(
- struct scic_sds_remote_node_context *this_rnc)
+ struct scic_sds_remote_node_context *sci_rnc)
{
union scu_remote_node_context *rnc_buffer;
rnc_buffer = scic_sds_controller_get_remote_node_context_buffer(
- scic_sds_remote_device_get_controller(this_rnc->device),
- this_rnc->remote_node_index
+ scic_sds_remote_device_get_controller(sci_rnc->device),
+ sci_rnc->remote_node_index
);
rnc_buffer->ssp.is_valid = true;
if (
- !this_rnc->device->is_direct_attached
- && this_rnc->device->target_protocols.u.bits.attached_stp_target
+ !sci_rnc->device->is_direct_attached
+ && sci_rnc->device->target_protocols.u.bits.attached_stp_target
) {
scic_sds_remote_device_post_request(
- this_rnc->device,
+ sci_rnc->device,
SCU_CONTEXT_COMMAND_POST_RNC_96
);
} else {
scic_sds_remote_device_post_request(
- this_rnc->device,
+ sci_rnc->device,
SCU_CONTEXT_COMMAND_POST_RNC_32
);
- if (this_rnc->device->is_direct_attached) {
+ if (sci_rnc->device->is_direct_attached) {
scic_sds_port_setup_transports(
- this_rnc->device->owning_port,
- this_rnc->remote_node_index
+ sci_rnc->device->owning_port,
+ sci_rnc->remote_node_index
);
}
}
/**
*
- * @this_rnc: The remote node context object that is to be invalidated.
+ * @sci_rnc: The remote node context object that is to be invalidated.
*
* This method will update the RNC buffer and post the invalidate request. none
*/
static void scic_sds_remote_node_context_invalidate_context_buffer(
- struct scic_sds_remote_node_context *this_rnc)
+ struct scic_sds_remote_node_context *sci_rnc)
{
union scu_remote_node_context *rnc_buffer;
rnc_buffer = scic_sds_controller_get_remote_node_context_buffer(
- scic_sds_remote_device_get_controller(this_rnc->device),
- this_rnc->remote_node_index
+ scic_sds_remote_device_get_controller(sci_rnc->device),
+ sci_rnc->remote_node_index
);
rnc_buffer->ssp.is_valid = false;
scic_sds_remote_device_post_request(
- this_rnc->device,
+ sci_rnc->device,
SCU_CONTEXT_COMMAND_POST_RNC_INVALIDATE
);
}
static void scic_sds_remote_node_context_posting_state_enter(
struct sci_base_object *object)
{
- struct scic_sds_remote_node_context *this_rnc;
+ struct scic_sds_remote_node_context *sci_rnc;
- this_rnc = (struct scic_sds_remote_node_context *)object;
+ sci_rnc = (struct scic_sds_remote_node_context *)object;
SET_STATE_HANDLER(
- this_rnc,
+ sci_rnc,
scic_sds_remote_node_context_state_handler_table,
SCIC_SDS_REMOTE_NODE_CONTEXT_POSTING_STATE
);
- scic_sds_remote_node_context_validate_context_buffer(this_rnc);
+ scic_sds_remote_node_context_validate_context_buffer(sci_rnc);
}
/**
typedef void (*scics_sds_remote_node_context_callback)(void *);
typedef enum sci_status (*scic_sds_remote_node_context_operation)(
- struct scic_sds_remote_node_context *this_rnc,
- scics_sds_remote_node_context_callback the_callback,
+ struct scic_sds_remote_node_context *sci_rnc,
+ scics_sds_remote_node_context_callback callback,
void *callback_parameter
);
typedef enum sci_status (*scic_sds_remote_node_context_suspend_operation)(
- struct scic_sds_remote_node_context *this_rnc,
+ struct scic_sds_remote_node_context *sci_rnc,
u32 suspension_type,
- scics_sds_remote_node_context_callback the_callback,
+ scics_sds_remote_node_context_callback callback,
void *callback_parameter
);
typedef enum sci_status (*scic_sds_remote_node_context_io_request)(
- struct scic_sds_remote_node_context *this_rnc,
- struct scic_sds_request *the_request
+ struct scic_sds_remote_node_context *sci_rnc,
+ struct scic_sds_request *sci_req
);
typedef enum sci_status (*scic_sds_remote_node_context_event_handler)(
- struct scic_sds_remote_node_context *this_rnc,
+ struct scic_sds_remote_node_context *sci_rnc,
u32 event_code
);
bool scic_sds_remote_node_context_is_ready(
- struct scic_sds_remote_node_context *this_rnc);
+ struct scic_sds_remote_node_context *sci_rnc);
#define scic_sds_remote_node_context_get_remote_node_index(rcn) \
((rnc)->remote_node_index)
/**
* This method returns the sgl element pair for the specificed sgl_pair index.
- * @this_request: This parameter specifies the IO request for which to retrieve
+ * @sci_req: This parameter specifies the IO request for which to retrieve
* the Scatter-Gather List element pair.
* @sgl_pair_index: This parameter specifies the index into the SGL element
* pair to be retrieved.
* This method returns a pointer to an struct scu_sgl_element_pair.
*/
static struct scu_sgl_element_pair *scic_sds_request_get_sgl_element_pair(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
u32 sgl_pair_index
) {
struct scu_task_context *task_context;
- task_context = (struct scu_task_context *)this_request->task_context_buffer;
+ task_context = (struct scu_task_context *)sci_req->task_context_buffer;
if (sgl_pair_index == 0) {
return &task_context->sgl_pair_ab;
return &task_context->sgl_pair_cd;
}
- return &this_request->sgl_element_pair_buffer[sgl_pair_index - 2];
+ return &sci_req->sgl_element_pair_buffer[sgl_pair_index - 2];
}
/**
* This function will build the SGL list for an IO request.
- * @this_request: This parameter specifies the IO request for which to build
+ * @sci_req: This parameter specifies the IO request for which to build
* the Scatter-Gather List.
*
*/
/**
* This method build the remainder of the IO request object.
- * @this_request: This parameter specifies the request object being constructed.
+ * @sci_req: This parameter specifies the request object being constructed.
*
* The scic_sds_general_request_construct() must be called before this call is
* valid. none
*/
static void scic_sds_ssp_io_request_assign_buffers(
- struct scic_sds_request *this_request)
+ struct scic_sds_request *sci_req)
{
- this_request->command_buffer =
- scic_sds_ssp_request_get_command_buffer(this_request);
- this_request->response_buffer =
- scic_sds_ssp_request_get_response_buffer(this_request);
- this_request->sgl_element_pair_buffer =
- scic_sds_ssp_request_get_sgl_element_buffer(this_request);
- this_request->sgl_element_pair_buffer =
- PTR_ALIGN(this_request->sgl_element_pair_buffer,
+ sci_req->command_buffer =
+ scic_sds_ssp_request_get_command_buffer(sci_req);
+ sci_req->response_buffer =
+ scic_sds_ssp_request_get_response_buffer(sci_req);
+ sci_req->sgl_element_pair_buffer =
+ scic_sds_ssp_request_get_sgl_element_buffer(sci_req);
+ sci_req->sgl_element_pair_buffer =
+ PTR_ALIGN(sci_req->sgl_element_pair_buffer,
sizeof(struct scu_sgl_element_pair));
- if (this_request->was_tag_assigned_by_user == false) {
- this_request->task_context_buffer =
- scic_sds_ssp_request_get_task_context_buffer(this_request);
- this_request->task_context_buffer =
- PTR_ALIGN(this_request->task_context_buffer,
+ if (sci_req->was_tag_assigned_by_user == false) {
+ sci_req->task_context_buffer =
+ scic_sds_ssp_request_get_task_context_buffer(sci_req);
+ sci_req->task_context_buffer =
+ PTR_ALIGN(sci_req->task_context_buffer,
SMP_CACHE_BYTES);
}
}
/**
* This method constructs the SSP Command IU data for this io request object.
- * @this_request: This parameter specifies the request object for which the SSP
+ * @sci_req: This parameter specifies the request object for which the SSP
* command information unit is being built.
*
*/
/**
* This method constructs the SSP Task IU data for this io request object.
- * @this_request:
+ * @sci_req:
*
*/
static void scic_sds_task_request_build_ssp_task_iu(
/**
* This method is will fill in the SCU Task Context for any type of SSP request.
- * @this_request:
+ * @sci_req:
* @task_context:
*
*/
task_context->address_modifier = 0;
- /* task_context->type.ssp.tag = this_request->io_tag; */
+ /* task_context->type.ssp.tag = sci_req->io_tag; */
task_context->task_phase = 0x01;
if (sds_request->was_tag_assigned_by_user) {
/**
* This method is will fill in the SCU Task Context for a SSP IO request.
- * @this_request:
+ * @sci_req:
*
*/
static void scu_ssp_io_request_construct_task_context(
/**
* This method will fill in the remainder of the io request object for SSP Task
* requests.
- * @this_request:
+ * @sci_req:
*
*/
static void scic_sds_ssp_task_request_assign_buffers(
- struct scic_sds_request *this_request)
+ struct scic_sds_request *sci_req)
{
/* Assign all of the buffer pointers */
- this_request->command_buffer =
- scic_sds_ssp_task_request_get_command_buffer(this_request);
- this_request->response_buffer =
- scic_sds_ssp_task_request_get_response_buffer(this_request);
- this_request->sgl_element_pair_buffer = NULL;
-
- if (this_request->was_tag_assigned_by_user == false) {
- this_request->task_context_buffer =
- scic_sds_ssp_task_request_get_task_context_buffer(this_request);
- this_request->task_context_buffer =
- PTR_ALIGN(this_request->task_context_buffer, SMP_CACHE_BYTES);
+ sci_req->command_buffer =
+ scic_sds_ssp_task_request_get_command_buffer(sci_req);
+ sci_req->response_buffer =
+ scic_sds_ssp_task_request_get_response_buffer(sci_req);
+ sci_req->sgl_element_pair_buffer = NULL;
+
+ if (sci_req->was_tag_assigned_by_user == false) {
+ sci_req->task_context_buffer =
+ scic_sds_ssp_task_request_get_task_context_buffer(sci_req);
+ sci_req->task_context_buffer =
+ PTR_ALIGN(sci_req->task_context_buffer, SMP_CACHE_BYTES);
}
}
* (i.e. non-raw frame) is being utilized to perform task management. -#
* control_frame == 1. This ensures that the proper endianess is set so
* that the bytes are transmitted in the right order for a task frame.
- * @this_request: This parameter specifies the task request object being
+ * @sci_req: This parameter specifies the task request object being
* constructed.
*
*/
static void scu_ssp_task_request_construct_task_context(
- struct scic_sds_request *this_request)
+ struct scic_sds_request *sci_req)
{
struct scu_task_context *task_context;
- task_context = scic_sds_request_get_task_context(this_request);
+ task_context = scic_sds_request_get_task_context(sci_req);
- scu_ssp_reqeust_construct_task_context(this_request, task_context);
+ scu_ssp_reqeust_construct_task_context(sci_req, task_context);
task_context->control_frame = 1;
task_context->priority = SCU_TASK_PRIORITY_HIGH;
/**
* This method constructs the SSP Command IU data for this ssp passthrough
* comand request object.
- * @this_request: This parameter specifies the request object for which the SSP
+ * @sci_req: This parameter specifies the request object for which the SSP
* command information unit is being built.
*
* enum sci_status, returns invalid parameter is cdb > 16
/**
* This method constructs the SATA request object.
- * @this_request:
+ * @sci_req:
* @sat_protocol:
* @transfer_length:
* @data_direction:
/**
*
- * @this_request: The SCIC_SDS_IO_REQUEST_T object for which the start
+ * @sci_req: The SCIC_SDS_IO_REQUEST_T object for which the start
* operation is to be executed.
* @frame_index: The frame index returned by the hardware for the reqeust
* object.
/**
*
- * @this_request: The SCIC_SDS_IO_REQUEST_T object for which the task start
+ * @sci_req: The SCIC_SDS_IO_REQUEST_T object for which the task start
* operation is to be executed.
*
* This method invokes the core state task complete handler for the
/**
* This method copies response data for requests returning response data
* instead of sense data.
- * @this_request: This parameter specifies the request object for which to copy
+ * @sci_req: This parameter specifies the request object for which to copy
* the response data.
*
*/
* TC (task context) completions for normal IO request (i.e. Task/Abort
* Completions of type 0). This method will update the
* SCIC_SDS_IO_REQUEST_T::status field.
- * @this_request: This parameter specifies the request for which a completion
+ * @sci_req: This parameter specifies the request for which a completion
* occurred.
* @completion_code: This parameter specifies the completion code received from
* the SCU.
*
*/
enum sci_status scic_sds_request_started_state_tc_completion_handler(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
u32 completion_code)
{
u8 data_present;
switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
scic_sds_request_set_status(
- this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+ sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
);
break;
* response stats to see if this is truly a failed request or a good
* request that just got completed early. */
struct sci_ssp_response_iu *response = (struct sci_ssp_response_iu *)
- this_request->response_buffer;
+ sci_req->response_buffer;
scic_word_copy_with_swap(
- this_request->response_buffer,
- this_request->response_buffer,
+ sci_req->response_buffer,
+ sci_req->response_buffer,
sizeof(struct sci_ssp_response_iu) / sizeof(u32)
);
if (response->status == 0) {
scic_sds_request_set_status(
- this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS_IO_DONE_EARLY
+ sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS_IO_DONE_EARLY
);
} else {
scic_sds_request_set_status(
- this_request,
+ sci_req,
SCU_TASK_DONE_CHECK_RESPONSE,
SCI_FAILURE_IO_RESPONSE_VALID
);
case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_CHECK_RESPONSE):
scic_word_copy_with_swap(
- this_request->response_buffer,
- this_request->response_buffer,
+ sci_req->response_buffer,
+ sci_req->response_buffer,
sizeof(struct sci_ssp_response_iu) / sizeof(u32)
);
scic_sds_request_set_status(
- this_request,
+ sci_req,
SCU_TASK_DONE_CHECK_RESPONSE,
SCI_FAILURE_IO_RESPONSE_VALID
);
* / @todo With TASK_DONE_RESP_LEN_ERR is the response frame guaranteed
* / to be received before this completion status is posted? */
response_buffer =
- (struct sci_ssp_response_iu *)this_request->response_buffer;
+ (struct sci_ssp_response_iu *)sci_req->response_buffer;
data_present =
response_buffer->data_present & SCI_SSP_RESPONSE_IU_DATA_PRESENT_MASK;
if ((data_present == 0x01) || (data_present == 0x02)) {
scic_sds_request_set_status(
- this_request,
+ sci_req,
SCU_TASK_DONE_CHECK_RESPONSE,
SCI_FAILURE_IO_RESPONSE_VALID
);
} else {
scic_sds_request_set_status(
- this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+ sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
);
}
break;
case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_UNEXP_SDBFIS):
case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_REG_ERR):
case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SDB_ERR):
- if (this_request->protocol == SCIC_STP_PROTOCOL) {
+ if (sci_req->protocol == SCIC_STP_PROTOCOL) {
scic_sds_request_set_status(
- this_request,
+ sci_req,
SCU_GET_COMPLETION_TL_STATUS(completion_code) >> SCU_COMPLETION_TL_STATUS_SHIFT,
SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED
);
} else {
scic_sds_request_set_status(
- this_request,
+ sci_req,
SCU_GET_COMPLETION_TL_STATUS(completion_code) >> SCU_COMPLETION_TL_STATUS_SHIFT,
SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
);
case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_PROTOCOL_NOT_SUPPORTED):
case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_CONNECTION_RATE_NOT_SUPPORTED):
scic_sds_request_set_status(
- this_request,
+ sci_req,
SCU_GET_COMPLETION_TL_STATUS(completion_code) >> SCU_COMPLETION_TL_STATUS_SHIFT,
SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED
);
case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_RNCNV_OUTBOUND):
default:
scic_sds_request_set_status(
- this_request,
+ sci_req,
SCU_GET_COMPLETION_TL_STATUS(completion_code) >> SCU_COMPLETION_TL_STATUS_SHIFT,
SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
);
*/
/* In all cases we will treat this as the completion of the IO request. */
- sci_base_state_machine_change_state(&this_request->state_machine,
+ sci_base_state_machine_change_state(&sci_req->state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED);
return SCI_SUCCESS;
}
* logged. enum sci_status SCI_SUCCESS SCI_FAILURE_INVALID_PARAMETER_VALUE
*/
static enum sci_status scic_sds_request_started_state_frame_handler(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
u32 frame_index)
{
enum sci_status status;
/* / @todo If this is a response frame we must record that we received it */
status = scic_sds_unsolicited_frame_control_get_header(
- &(scic_sds_request_get_controller(this_request)->uf_control),
+ &(scic_sds_request_get_controller(sci_req)->uf_control),
frame_index,
(void **)&frame_header
);
struct sci_ssp_response_iu *response_buffer;
status = scic_sds_unsolicited_frame_control_get_buffer(
- &(scic_sds_request_get_controller(this_request)->uf_control),
+ &(scic_sds_request_get_controller(sci_req)->uf_control),
frame_index,
(void **)&response_buffer
);
scic_word_copy_with_swap(
- this_request->response_buffer,
+ sci_req->response_buffer,
(u32 *)response_buffer,
sizeof(struct sci_ssp_response_iu)
);
- response_buffer = (struct sci_ssp_response_iu *)this_request->response_buffer;
+ response_buffer = (struct sci_ssp_response_iu *)sci_req->response_buffer;
if ((response_buffer->data_present == 0x01) ||
(response_buffer->data_present == 0x02)) {
scic_sds_request_set_status(
- this_request,
+ sci_req,
SCU_TASK_DONE_CHECK_RESPONSE,
SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
);
} else
scic_sds_request_set_status(
- this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+ sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
);
} else
/* This was not a response frame why did it get forwarded? */
- dev_err(scic_to_dev(this_request->owning_controller),
+ dev_err(scic_to_dev(sci_req->owning_controller),
"%s: SCIC IO Request 0x%p received unexpected "
"frame %d type 0x%02x\n",
__func__,
- this_request,
+ sci_req,
frame_index,
frame_header->frame_type);
* In any case we are done with this frame buffer return it to the
* controller */
scic_sds_controller_release_frame(
- this_request->owning_controller, frame_index
+ sci_req->owning_controller, frame_index
);
return SCI_SUCCESS;
* transitions to the completed state. enum sci_status SCI_SUCCESS
*/
static enum sci_status scic_sds_request_aborting_state_tc_completion_handler(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
u32 completion_code)
{
switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
case (SCU_TASK_DONE_GOOD << SCU_COMPLETION_TL_STATUS_SHIFT):
case (SCU_TASK_DONE_TASK_ABORT << SCU_COMPLETION_TL_STATUS_SHIFT):
scic_sds_request_set_status(
- this_request, SCU_TASK_DONE_TASK_ABORT, SCI_FAILURE_IO_TERMINATED
+ sci_req, SCU_TASK_DONE_TASK_ABORT, SCI_FAILURE_IO_TERMINATED
);
- sci_base_state_machine_change_state(&this_request->state_machine,
+ sci_base_state_machine_change_state(&sci_req->state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED);
break;
* completion. enum sci_status SCI_SUCCESS
*/
static enum sci_status scic_sds_request_aborting_state_frame_handler(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
u32 frame_index)
{
/* TODO: Is it even possible to get an unsolicited frame in the aborting state? */
scic_sds_controller_release_frame(
- this_request->owning_controller, frame_index);
+ sci_req->owning_controller, frame_index);
return SCI_SUCCESS;
}
static void scic_sds_request_initial_state_enter(
struct sci_base_object *object)
{
- struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+ struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
SET_STATE_HANDLER(
- this_request,
+ sci_req,
scic_sds_request_state_handler_table,
SCI_BASE_REQUEST_STATE_INITIAL
);
static void scic_sds_request_constructed_state_enter(
struct sci_base_object *object)
{
- struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+ struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
SET_STATE_HANDLER(
- this_request,
+ sci_req,
scic_sds_request_state_handler_table,
SCI_BASE_REQUEST_STATE_CONSTRUCTED
);
static void scic_sds_request_started_state_enter(
struct sci_base_object *object)
{
- struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+ struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
SET_STATE_HANDLER(
- this_request,
+ sci_req,
scic_sds_request_state_handler_table,
SCI_BASE_REQUEST_STATE_STARTED
);
/*
* Most of the request state machines have a started substate machine so
* start its execution on the entry to the started state. */
- if (this_request->has_started_substate_machine == true)
- sci_base_state_machine_start(&this_request->started_substate_machine);
+ if (sci_req->has_started_substate_machine == true)
+ sci_base_state_machine_start(&sci_req->started_substate_machine);
}
/**
static void scic_sds_request_started_state_exit(
struct sci_base_object *object)
{
- struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+ struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
- if (this_request->has_started_substate_machine == true)
- sci_base_state_machine_stop(&this_request->started_substate_machine);
+ if (sci_req->has_started_substate_machine == true)
+ sci_base_state_machine_stop(&sci_req->started_substate_machine);
}
/**
static void scic_sds_request_aborting_state_enter(
struct sci_base_object *object)
{
- struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+ struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
/* Setting the abort bit in the Task Context is required by the silicon. */
- this_request->task_context_buffer->abort = 1;
+ sci_req->task_context_buffer->abort = 1;
SET_STATE_HANDLER(
- this_request,
+ sci_req,
scic_sds_request_state_handler_table,
SCI_BASE_REQUEST_STATE_ABORTING
);
static void scic_sds_request_final_state_enter(
struct sci_base_object *object)
{
- struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+ struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
SET_STATE_HANDLER(
- this_request,
+ sci_req,
scic_sds_request_state_handler_table,
SCI_BASE_REQUEST_STATE_FINAL
);
*
* This macro will return the controller for this io request object
*/
-#define scic_sds_request_get_controller(this_request) \
- ((this_request)->owning_controller)
+#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(this_request) \
- ((this_request)->target_device)
+#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(this_request) \
- scic_sds_remote_device_get_port(scic_sds_request_get_device(this_request))
+#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(this_request) \
- ((this_request)->post_context)
+#define scic_sds_request_get_post_context(sci_req) \
+ ((sci_req)->post_context)
/**
* scic_sds_request_get_task_context() -
* ***************************************************************************** */
void scic_sds_request_build_sgl(
- struct scic_sds_request *this_request);
+ struct scic_sds_request *sci_req);
void scic_sds_stp_request_assign_buffers(
- struct scic_sds_request *this_request);
+ struct scic_sds_request *sci_req);
void scic_sds_smp_request_assign_buffers(
- struct scic_sds_request *this_request);
+ struct scic_sds_request *sci_req);
/* --------------------------------------------------------------------------- */
enum sci_status scic_sds_request_start(
- struct scic_sds_request *this_request);
+ struct scic_sds_request *sci_req);
enum sci_status scic_sds_io_request_terminate(
- struct scic_sds_request *this_request);
+ struct scic_sds_request *sci_req);
enum sci_status scic_sds_io_request_complete(
- struct scic_sds_request *this_request);
+ struct scic_sds_request *sci_req);
void scic_sds_io_request_copy_response(
- struct scic_sds_request *this_request);
+ struct scic_sds_request *sci_req);
enum sci_status scic_sds_io_request_event_handler(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
u32 event_code);
enum sci_status scic_sds_io_request_frame_handler(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
u32 frame_index);
enum sci_status scic_sds_task_request_terminate(
- struct scic_sds_request *this_request);
+ struct scic_sds_request *sci_req);
/*
* *****************************************************************************
* ***************************************************************************** */
enum sci_status scic_sds_request_started_state_abort_handler(
- struct scic_sds_request *request);
+ struct scic_sds_request *sci_req);
enum sci_status scic_sds_request_started_state_tc_completion_handler(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
u32 completion_code);
#endif /* _SCIC_SDS_IO_REQUEST_H_ */
struct scic_sds_request *request)
{
enum sci_status status;
- struct scic_sds_request *the_request;
+ struct scic_sds_request *sci_req;
- the_request = (struct scic_sds_request *)request;
+ sci_req = (struct scic_sds_request *)request;
- status = scic_sds_io_request_complete(the_request);
+ status = scic_sds_io_request_complete(sci_req);
if (status == SCI_SUCCESS) {
status = scic_sds_port_complete_io(
- device->owning_port, device, the_request);
+ device->owning_port, device, sci_req);
if (status == SCI_SUCCESS) {
scic_sds_remote_device_decrement_request_count(device);
"failed with status %d.\n",
__func__,
device,
- the_request,
+ sci_req,
device->owning_port,
status);
}
/**
* This is frame handler for smp device ready cmd substate.
- * @this_device: This is the device object that is receiving the frame.
+ * @sci_dev: This is the device object that is receiving the frame.
* @frame_index: The index for the frame received.
*
* enum sci_status
*/
static enum sci_status scic_sds_smp_remote_device_ready_cmd_substate_frame_handler(
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
u32 frame_index)
{
enum sci_status status;
* / in this state. All unsolicited frames are forwarded to the io request
* / object. */
status = scic_sds_io_request_frame_handler(
- this_device->working_request,
+ sci_dev->working_request,
frame_index
);
#include "scu_task_context.h"
static void scu_smp_request_construct_task_context(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
struct smp_request *smp_request);
/**
/**
* This method build the remainder of the IO request object.
- * @this_request: This parameter specifies the request object being constructed.
+ * @sci_req: This parameter specifies the request object being constructed.
*
* The scic_sds_general_request_construct() must be called before this call is
* valid. none
*/
void scic_sds_smp_request_assign_buffers(
- struct scic_sds_request *this_request)
+ struct scic_sds_request *sci_req)
{
/* Assign all of the buffer pointers */
- this_request->command_buffer =
- scic_sds_smp_request_get_command_buffer(this_request);
- this_request->response_buffer =
- scic_sds_smp_request_get_response_buffer(this_request);
- this_request->sgl_element_pair_buffer = NULL;
-
- if (this_request->was_tag_assigned_by_user == false) {
- this_request->task_context_buffer =
- scic_sds_smp_request_get_task_context_buffer(this_request);
- this_request->task_context_buffer =
- PTR_ALIGN(this_request->task_context_buffer, SMP_CACHE_BYTES);
+ sci_req->command_buffer =
+ scic_sds_smp_request_get_command_buffer(sci_req);
+ sci_req->response_buffer =
+ scic_sds_smp_request_get_response_buffer(sci_req);
+ sci_req->sgl_element_pair_buffer = NULL;
+
+ if (sci_req->was_tag_assigned_by_user == false) {
+ sci_req->task_context_buffer =
+ scic_sds_smp_request_get_task_context_buffer(sci_req);
+ sci_req->task_context_buffer =
+ PTR_ALIGN(sci_req->task_context_buffer, SMP_CACHE_BYTES);
}
}
* (i.e. non-raw frame) is being utilized to perform task management. -#
* control_frame == 1. This ensures that the proper endianess is set so
* that the bytes are transmitted in the right order for a smp request frame.
- * @this_request: This parameter specifies the smp request object being
+ * @sci_req: This parameter specifies the smp request object being
* constructed.
*
*/
* for a response frame. It will copy the response data, release the
* unsolicited frame, and transition the request to the
* SCI_BASE_REQUEST_STATE_COMPLETED state.
- * @this_request: This parameter specifies the request for which the
+ * @sci_req: This parameter specifies the request for which the
* unsolicited frame was received.
* @frame_index: This parameter indicates the unsolicited frame index that
* should contain the response.
* indicates successful processing of the TC response.
*/
static enum sci_status scic_sds_smp_request_await_response_frame_handler(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
u32 frame_index)
{
enum sci_status status;
void *frame_header;
- struct smp_response_header *this_frame_header;
- u8 *user_smp_buffer = this_request->response_buffer;
+ struct smp_response_header *rsp_hdr;
+ u8 *user_smp_buffer = sci_req->response_buffer;
status = scic_sds_unsolicited_frame_control_get_header(
- &(scic_sds_request_get_controller(this_request)->uf_control),
+ &(scic_sds_request_get_controller(sci_req)->uf_control),
frame_index,
&frame_header
);
frame_header,
sizeof(struct smp_response_header) / sizeof(u32)
);
- this_frame_header = (struct smp_response_header *)user_smp_buffer;
+ rsp_hdr = (struct smp_response_header *)user_smp_buffer;
- if (this_frame_header->smp_frame_type == SMP_FRAME_TYPE_RESPONSE) {
+ if (rsp_hdr->smp_frame_type == SMP_FRAME_TYPE_RESPONSE) {
void *smp_response_buffer;
status = scic_sds_unsolicited_frame_control_get_buffer(
- &(scic_sds_request_get_controller(this_request)->uf_control),
+ &(scic_sds_request_get_controller(sci_req)->uf_control),
frame_index,
&smp_response_buffer
);
smp_response_buffer,
sizeof(union smp_response_body) / sizeof(u32)
);
- if (this_frame_header->function == SMP_FUNCTION_DISCOVER) {
- struct smp_response *this_smp_response;
+ if (rsp_hdr->function == SMP_FUNCTION_DISCOVER) {
+ struct smp_response *smp_resp;
- this_smp_response = (struct smp_response *)user_smp_buffer;
+ smp_resp = (struct smp_response *)user_smp_buffer;
/*
* Some expanders only report an attached SATA device, and
* not an STP target. Since the core depends on the STP
* target attribute to correctly build I/O, set the bit now
* if necessary. */
- if (this_smp_response->response.discover.protocols.u.bits.attached_sata_device
- && !this_smp_response->response.discover.protocols.u.bits.attached_stp_target) {
- this_smp_response->response.discover.protocols.u.bits.attached_stp_target = 1;
+ if (smp_resp->response.discover.protocols.u.bits.attached_sata_device
+ && !smp_resp->response.discover.protocols.u.bits.attached_stp_target) {
+ smp_resp->response.discover.protocols.u.bits.attached_stp_target = 1;
- dev_dbg(scic_to_dev(this_request->owning_controller),
+ dev_dbg(scic_to_dev(sci_req->owning_controller),
"%s: scic_sds_smp_request_await_response_frame_handler(0x%p) Found SATA dev, setting STP bit.\n",
- __func__, this_request);
+ __func__, sci_req);
}
}
/*
* copy the smp response to framework smp request's response buffer.
- * scic_sds_smp_request_copy_response(this_request); */
+ * scic_sds_smp_request_copy_response(sci_req); */
scic_sds_request_set_status(
- this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+ sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
);
sci_base_state_machine_change_state(
- &this_request->started_substate_machine,
+ &sci_req->started_substate_machine,
SCIC_SDS_SMP_REQUEST_STARTED_SUBSTATE_AWAIT_TC_COMPLETION
);
} else {
/* This was not a response frame why did it get forwarded? */
- dev_err(scic_to_dev(this_request->owning_controller),
+ dev_err(scic_to_dev(sci_req->owning_controller),
"%s: SCIC SMP Request 0x%p received unexpected frame "
"%d type 0x%02x\n",
__func__,
- this_request,
+ sci_req,
frame_index,
- this_frame_header->smp_frame_type);
+ rsp_hdr->smp_frame_type);
scic_sds_request_set_status(
- this_request,
+ sci_req,
SCU_TASK_DONE_SMP_FRM_TYPE_ERR,
SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
);
sci_base_state_machine_change_state(
- &this_request->state_machine,
+ &sci_req->state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED
);
}
scic_sds_controller_release_frame(
- this_request->owning_controller, frame_index
+ sci_req->owning_controller, frame_index
);
return SCI_SUCCESS;
* This method processes an abnormal TC completion while the SMP request is
* waiting for a response frame. It decides what happened to the IO based
* on TC completion status.
- * @this_request: This parameter specifies the request for which the TC
+ * @sci_req: This parameter specifies the request for which the TC
* completion was received.
* @completion_code: This parameter indicates the completion status information
* for the TC.
* this method always returns success.
*/
static enum sci_status scic_sds_smp_request_await_response_tc_completion_handler(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
u32 completion_code)
{
switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
* In the AWAIT RESPONSE state, any TC completion is unexpected.
* but if the TC has success status, we complete the IO anyway. */
scic_sds_request_set_status(
- this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+ sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
);
sci_base_state_machine_change_state(
- &this_request->state_machine,
+ &sci_req->state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED);
break;
* break the connection and set TC completion with one of these SMP_XXX_XX_ERR
* status. For these type of error, we ask scic user to retry the request. */
scic_sds_request_set_status(
- this_request, SCU_TASK_DONE_SMP_RESP_TO_ERR, SCI_FAILURE_RETRY_REQUIRED
+ sci_req, SCU_TASK_DONE_SMP_RESP_TO_ERR, SCI_FAILURE_RETRY_REQUIRED
);
sci_base_state_machine_change_state(
- &this_request->state_machine,
+ &sci_req->state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED);
break;
* All other completion status cause the IO to be complete. If a NAK
* was received, then it is up to the user to retry the request. */
scic_sds_request_set_status(
- this_request,
+ sci_req,
SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
);
sci_base_state_machine_change_state(
- &this_request->state_machine,
+ &sci_req->state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED);
break;
}
* determine if the SMP request was sent successfully. If the SMP request
* was sent successfully, then the state for the SMP request transits to
* waiting for a response frame.
- * @this_request: This parameter specifies the request for which the TC
+ * @sci_req: This parameter specifies the request for which the TC
* completion was received.
* @completion_code: This parameter indicates the completion status information
* for the TC.
* this method always returns success.
*/
static enum sci_status scic_sds_smp_request_await_tc_completion_tc_completion_handler(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
u32 completion_code)
{
switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
scic_sds_request_set_status(
- this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+ sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
);
sci_base_state_machine_change_state(
- &this_request->state_machine,
+ &sci_req->state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED);
break;
* All other completion status cause the IO to be complete. If a NAK
* was received, then it is up to the user to retry the request. */
scic_sds_request_set_status(
- this_request,
+ sci_req,
SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
);
sci_base_state_machine_change_state(
- &this_request->state_machine,
+ &sci_req->state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED);
break;
}
static void scic_sds_smp_request_started_await_response_substate_enter(
struct sci_base_object *object)
{
- struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+ struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
SET_STATE_HANDLER(
- this_request,
+ sci_req,
scic_sds_smp_request_started_substate_handler_table,
SCIC_SDS_SMP_REQUEST_STARTED_SUBSTATE_AWAIT_RESPONSE
);
static void scic_sds_smp_request_started_await_tc_completion_substate_enter(
struct sci_base_object *object)
{
- struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+ struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
SET_STATE_HANDLER(
- this_request,
+ sci_req,
scic_sds_smp_request_started_substate_handler_table,
SCIC_SDS_SMP_REQUEST_STARTED_SUBSTATE_AWAIT_TC_COMPLETION
);
u32 scic_sds_smp_request_get_object_size(void);
-void scic_sds_smp_request_copy_response(
- struct scic_sds_request *this_request);
+void scic_sds_smp_request_copy_response(struct scic_sds_request *sci_req);
#endif /* _SCIC_SDS_SMP_REQUEST_T_ */
* determine if the RAW task management frame was sent successfully. If the
* raw frame was sent successfully, then the state for the task request
* transitions to waiting for a response frame.
- * @this_request: This parameter specifies the request for which the TC
+ * @sci_req: This parameter specifies the request for which the TC
* completion was received.
* @completion_code: This parameter indicates the completion status information
* for the TC.
* this method always returns success.
*/
static enum sci_status scic_sds_ssp_task_request_await_tc_completion_tc_completion_handler(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
u32 completion_code)
{
switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
scic_sds_request_set_status(
- this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+ sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
);
sci_base_state_machine_change_state(
- &this_request->started_substate_machine,
+ &sci_req->started_substate_machine,
SCIC_SDS_IO_REQUEST_STARTED_TASK_MGMT_SUBSTATE_AWAIT_TC_RESPONSE
);
break;
* timeout if the task IU wasn't received successfully.
* There is a potential for receiving multiple task responses if we
* decide to send the task IU again. */
- dev_warn(scic_to_dev(this_request->owning_controller),
+ dev_warn(scic_to_dev(sci_req->owning_controller),
"%s: TaskRequest:0x%p CompletionCode:%x - "
"ACK/NAK timeout\n",
__func__,
- this_request,
+ sci_req,
completion_code);
sci_base_state_machine_change_state(
- &this_request->started_substate_machine,
+ &sci_req->started_substate_machine,
SCIC_SDS_IO_REQUEST_STARTED_TASK_MGMT_SUBSTATE_AWAIT_TC_RESPONSE
);
break;
* All other completion status cause the IO to be complete. If a NAK
* was received, then it is up to the user to retry the request. */
scic_sds_request_set_status(
- this_request,
+ sci_req,
SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
);
- sci_base_state_machine_change_state(&this_request->state_machine,
+ sci_base_state_machine_change_state(&sci_req->state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED);
break;
}
* This method is responsible for processing a terminate/abort request for this
* TC while the request is waiting for the task management response
* unsolicited frame.
- * @this_request: This parameter specifies the request for which the
+ * @sci_req: This parameter specifies the request for which the
* termination was requested.
*
* This method returns an indication as to whether the abort request was
* waiting for a response frame. It will copy the response data, release
* the unsolicited frame, and transition the request to the
* SCI_BASE_REQUEST_STATE_COMPLETED state.
- * @this_request: This parameter specifies the request for which the
+ * @sci_req: This parameter specifies the request for which the
* unsolicited frame was received.
* @frame_index: This parameter indicates the unsolicited frame index that
* should contain the response.
static void scic_sds_io_request_started_task_mgmt_await_tc_completion_substate_enter(
struct sci_base_object *object)
{
- struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+ struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
SET_STATE_HANDLER(
- this_request,
+ sci_req,
scic_sds_ssp_task_request_started_substate_handler_table,
SCIC_SDS_IO_REQUEST_STARTED_TASK_MGMT_SUBSTATE_AWAIT_TC_COMPLETION
);
static void scic_sds_io_request_started_task_mgmt_await_task_response_substate_enter(
struct sci_base_object *object)
{
- struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+ struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
SET_STATE_HANDLER(
- this_request,
+ sci_req,
scic_sds_ssp_task_request_started_substate_handler_table,
SCIC_SDS_IO_REQUEST_STARTED_TASK_MGMT_SUBSTATE_AWAIT_TC_RESPONSE
);
/**
* This method will fill in the SCU Task Context for a PACKET fis. And
* construct the request STARTED sub-state machine for Packet Protocol IO.
- * @this_request: This parameter specifies the stp packet request object being
+ * @sci_req: This parameter specifies the stp packet request object being
* constructed.
*
*/
enum sci_status scic_sds_stp_packet_request_construct(
- struct scic_sds_request *this_request)
+ struct scic_sds_request *sci_req)
{
struct sata_fis_reg_h2d *h2d_fis =
scic_stp_io_request_get_h2d_reg_address(
- this_request
+ sci_req
);
/*
* need to make change to Packet Fis features field. */
h2d_fis->features = h2d_fis->features | ATA_PACKET_FEATURE_DMA;
- scic_sds_stp_non_ncq_request_construct(this_request);
+ scic_sds_stp_non_ncq_request_construct(sci_req);
/* Build the Packet Fis task context structure */
scu_stp_raw_request_construct_task_context(
- (struct scic_sds_stp_request *)this_request,
- this_request->task_context_buffer
+ (struct scic_sds_stp_request *)sci_req,
+ sci_req->task_context_buffer
);
sci_base_state_machine_construct(
- &this_request->started_substate_machine,
- &this_request->parent.parent,
+ &sci_req->started_substate_machine,
+ &sci_req->parent.parent,
scic_sds_stp_packet_request_started_substate_table,
SCIC_SDS_STP_PACKET_REQUEST_STARTED_PACKET_PHASE_AWAIT_TC_COMPLETION_SUBSTATE
);
* utilized to perform task management. -# control_frame == 1. This ensures
* that the proper endianess is set so that the bytes are transmitted in the
* right order for a smp request frame.
- * @this_request: This parameter specifies the smp request object being
+ * @sci_req: This parameter specifies the smp request object being
* constructed.
* @task_context: The task_context to be reconstruct for packet request command
* phase.
*
*/
void scu_stp_packet_request_command_phase_construct_task_context(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
struct scu_task_context *task_context)
{
void *atapi_cdb;
u32 atapi_cdb_length;
- struct scic_sds_stp_request *stp_request = (struct scic_sds_stp_request *)this_request;
+ struct scic_sds_stp_request *stp_request = (struct scic_sds_stp_request *)sci_req;
/*
* reference: SSTL 1.13.4.2
* task_type, sata_direction */
- if (scic_cb_io_request_get_data_direction(this_request->user_request)
+ if (scic_cb_io_request_get_data_direction(sci_req->user_request)
== SCI_IO_REQUEST_DATA_OUT) {
task_context->task_type = SCU_TASK_TYPE_PACKET_DMA_OUT;
task_context->sata_direction = 0;
/*
* Copy in the command IU with CDB so that the commandIU address doesn't
* change. */
- memset(this_request->command_buffer, 0, sizeof(struct sata_fis_reg_h2d));
+ memset(sci_req->command_buffer, 0, sizeof(struct sata_fis_reg_h2d));
atapi_cdb =
- scic_cb_stp_packet_io_request_get_cdb_address(this_request->user_request);
+ scic_cb_stp_packet_io_request_get_cdb_address(sci_req->user_request);
atapi_cdb_length =
- scic_cb_stp_packet_io_request_get_cdb_length(this_request->user_request);
+ scic_cb_stp_packet_io_request_get_cdb_length(sci_req->user_request);
- memcpy(((u8 *)this_request->command_buffer + sizeof(u32)), atapi_cdb, atapi_cdb_length);
+ memcpy(((u8 *)sci_req->command_buffer + sizeof(u32)), atapi_cdb, atapi_cdb_length);
atapi_cdb_length =
max(atapi_cdb_length, stp_request->type.packet.device_preferred_cdb_length);
/* retry counter */
task_context->stp_retry_count = 0;
- if (scic_cb_request_is_initial_construction(this_request->user_request)) {
+ if (scic_cb_request_is_initial_construction(sci_req->user_request)) {
/* data transfer size. */
task_context->transfer_length_bytes =
- scic_cb_io_request_get_transfer_length(this_request->user_request);
+ scic_cb_io_request_get_transfer_length(sci_req->user_request);
/* setup sgl */
- scic_sds_request_build_sgl(this_request);
+ scic_sds_request_build_sgl(sci_req);
} else {
/* data transfer size, need to be 4 bytes aligned. */
task_context->transfer_length_bytes = (SCSI_FIXED_SENSE_DATA_BASE_LENGTH + 2);
- scic_sds_stp_packet_internal_request_sense_build_sgl(this_request);
+ scic_sds_stp_packet_internal_request_sense_build_sgl(sci_req);
}
}
* This method will fill in the SCU Task Context for a DATA fis containing CDB
* in Raw Frame type. The TC for previous Packet fis was already there, we
* only need to change the H2D fis content.
- * @this_request: This parameter specifies the smp request object being
+ * @sci_req: This parameter specifies the smp request object being
* constructed.
* @task_context: The task_context to be reconstruct for packet request command
* phase.
*
*/
void scu_stp_packet_request_command_phase_reconstruct_raw_frame_task_context(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
struct scu_task_context *task_context)
{
void *atapi_cdb =
- scic_cb_stp_packet_io_request_get_cdb_address(this_request->user_request);
+ scic_cb_stp_packet_io_request_get_cdb_address(sci_req->user_request);
u32 atapi_cdb_length =
- scic_cb_stp_packet_io_request_get_cdb_length(this_request->user_request);
+ scic_cb_stp_packet_io_request_get_cdb_length(sci_req->user_request);
- memset(this_request->command_buffer, 0, sizeof(struct sata_fis_reg_h2d));
- memcpy(((u8 *)this_request->command_buffer + sizeof(u32)), atapi_cdb, atapi_cdb_length);
+ memset(sci_req->command_buffer, 0, sizeof(struct sata_fis_reg_h2d));
+ memcpy(((u8 *)sci_req->command_buffer + sizeof(u32)), atapi_cdb, atapi_cdb_length);
memset(&(task_context->type.stp), 0, sizeof(struct stp_task_context));
task_context->type.stp.fis_type = SATA_FIS_TYPE_DATA;
* *@brief This methods decode the D2H status FIS and retrieve the sense data,
* then pass the sense data to user request.
*
- ***@param[in] this_request The request receive D2H status FIS.
+ ***@param[in] sci_req The request receive D2H status FIS.
***@param[in] status_fis The D2H status fis to be processed.
*
*/
enum sci_status scic_sds_stp_packet_request_process_status_fis(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
struct sata_fis_reg_d2h *status_fis)
{
enum sci_status status = SCI_SUCCESS;
* command using this request response buffer, only one sge is
* needed.
*
- ***@param[in] this_request The request receive request sense data.
+ ***@param[in] sci_req The request receive request sense data.
*
*/
void scic_sds_stp_packet_internal_request_sense_build_sgl(
* determine if the Packet FIS was sent successfully. If the Packet FIS was
* sent successfully, then the state for the Packet request transits to
* waiting for a PIO SETUP frame.
- * @this_request: This parameter specifies the request for which the TC
+ * @sci_req: This parameter specifies the request for which the TC
* completion was received.
* @completion_code: This parameter indicates the completion status information
* for the TC.
* this method always returns success.
*/
enum sci_status scic_sds_stp_packet_request_packet_phase_await_tc_completion_tc_completion_handler(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
u32 completion_code)
{
enum sci_status status = SCI_SUCCESS;
switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
scic_sds_request_set_status(
- this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+ sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
);
sci_base_state_machine_change_state(
- &this_request->started_substate_machine,
+ &sci_req->started_substate_machine,
SCIC_SDS_STP_PACKET_REQUEST_STARTED_PACKET_PHASE_AWAIT_PIO_SETUP_SUBSTATE
);
break;
* All other completion status cause the IO to be complete. If a NAK
* was received, then it is up to the user to retry the request. */
scic_sds_request_set_status(
- this_request,
+ sci_req,
SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
);
sci_base_state_machine_change_state(
- &this_request->parent.state_machine,
+ &sci_req->parent.state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED
);
break;
* waiting for a PIO SETUP FIS. It will release the unsolicited frame, and
* transition the request to the COMMAND_PHASE_AWAIT_TC_COMPLETION_SUBSTATE
* state.
- * @this_request: This parameter specifies the request for which the
+ * @sci_req: This parameter specifies the request for which the
* unsolicited frame was received.
* @frame_index: This parameter indicates the unsolicited frame index that
* should contain the response.
enum sci_status status;
struct sata_fis_header *frame_header;
u32 *frame_buffer;
- struct scic_sds_stp_request *this_request;
+ struct scic_sds_stp_request *sci_req;
- this_request = (struct scic_sds_stp_request *)request;
+ sci_req = (struct scic_sds_stp_request *)request;
status = scic_sds_unsolicited_frame_control_get_header(
- &(this_request->parent.owning_controller->uf_control),
+ &(sci_req->parent.owning_controller->uf_control),
frame_index,
(void **)&frame_header
);
* Get from the frame buffer the PIO Setup Data, although we don't need
* any info from this pio setup fis. */
scic_sds_unsolicited_frame_control_get_buffer(
- &(this_request->parent.owning_controller->uf_control),
+ &(sci_req->parent.owning_controller->uf_control),
frame_index,
(void **)&frame_buffer
);
* Get the data from the PIO Setup
* The SCU Hardware returns first word in the frame_header and the rest
* of the data is in the frame buffer so we need to back up one dword */
- this_request->type.packet.device_preferred_cdb_length =
+ sci_req->type.packet.device_preferred_cdb_length =
(u16)((struct sata_fis_pio_setup *)(&frame_buffer[-1]))->transfter_count;
/* Frame has been decoded return it to the controller */
scic_sds_controller_release_frame(
- this_request->parent.owning_controller, frame_index
+ sci_req->parent.owning_controller, frame_index
);
sci_base_state_machine_change_state(
- &this_request->parent.started_substate_machine,
+ &sci_req->parent.started_substate_machine,
SCIC_SDS_STP_PACKET_REQUEST_STARTED_COMMAND_PHASE_AWAIT_TC_COMPLETION_SUBSTATE
);
} else
dev_err(scic_to_dev(request->owning_controller),
"%s: SCIC IO Request 0x%p could not get frame header "
"for frame index %d, status %x\n",
- __func__, this_request, frame_index, status);
+ __func__, sci_req, frame_index, status);
return status;
}
* successfully, then the state for the packet request transits to COMPLETE
* state. If not successfuly, the request transits to
* COMMAND_PHASE_AWAIT_D2H_FIS_SUBSTATE.
- * @this_request: This parameter specifies the request for which the TC
+ * @sci_req: This parameter specifies the request for which the TC
* completion was received.
* @completion_code: This parameter indicates the completion status information
* for the TC.
* this method always returns success.
*/
enum sci_status scic_sds_stp_packet_request_command_phase_await_tc_completion_tc_completion_handler(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
u32 completion_code)
{
enum sci_status status = SCI_SUCCESS;
u8 sat_packet_protocol =
- scic_cb_request_get_sat_protocol(this_request->user_request);
+ scic_cb_request_get_sat_protocol(sci_req->user_request);
switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
case (SCU_TASK_DONE_GOOD << SCU_COMPLETION_TL_STATUS_SHIFT):
scic_sds_request_set_status(
- this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+ sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
);
if (sat_packet_protocol == SAT_PROTOCOL_PACKET_DMA_DATA_IN
|| sat_packet_protocol == SAT_PROTOCOL_PACKET_DMA_DATA_OUT
)
sci_base_state_machine_change_state(
- &this_request->parent.state_machine,
+ &sci_req->parent.state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED
);
else
sci_base_state_machine_change_state(
- &this_request->started_substate_machine,
+ &sci_req->started_substate_machine,
SCIC_SDS_STP_PACKET_REQUEST_STARTED_COMMAND_PHASE_AWAIT_D2H_FIS_SUBSTATE
);
break;
case (SCU_TASK_DONE_UNEXP_FIS << SCU_COMPLETION_TL_STATUS_SHIFT):
- if (scic_io_request_get_number_of_bytes_transferred(this_request) <
- scic_cb_io_request_get_transfer_length(this_request->user_request)) {
+ if (scic_io_request_get_number_of_bytes_transferred(sci_req) <
+ scic_cb_io_request_get_transfer_length(sci_req->user_request)) {
scic_sds_request_set_status(
- this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS_IO_DONE_EARLY
+ sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS_IO_DONE_EARLY
);
sci_base_state_machine_change_state(
- &this_request->parent.state_machine,
+ &sci_req->parent.state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED
);
- status = this_request->sci_status;
+ status = sci_req->sci_status;
}
break;
case (SCU_TASK_DONE_EXCESS_DATA << SCU_COMPLETION_TL_STATUS_SHIFT):
/* In this case, there is no UF coming after. compelte the IO now. */
scic_sds_request_set_status(
- this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+ sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
);
sci_base_state_machine_change_state(
- &this_request->parent.state_machine,
+ &sci_req->parent.state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED
);
break;
default:
- if (this_request->sci_status != SCI_SUCCESS) { /* The io status was set already. This means an UF for the status
+ if (sci_req->sci_status != SCI_SUCCESS) { /* The io status was set already. This means an UF for the status
* fis was received already.
*/
* A device suspension event is expected, we need to have the device
* coming out of suspension, then complete the IO. */
sci_base_state_machine_change_state(
- &this_request->started_substate_machine,
+ &sci_req->started_substate_machine,
SCIC_SDS_STP_PACKET_REQUEST_STARTED_COMPLETION_DELAY_SUBSTATE
);
/* change the device state to ATAPI_ERROR. */
sci_base_state_machine_change_state(
- &this_request->target_device->ready_substate_machine,
+ &sci_req->target_device->ready_substate_machine,
SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_ATAPI_ERROR
);
- status = this_request->sci_status;
+ status = sci_req->sci_status;
} else { /* If receiving any non-sucess TC status, no UF received yet, then an UF for
* the status fis is coming after.
*/
scic_sds_request_set_status(
- this_request,
+ sci_req,
SCU_TASK_DONE_CHECK_RESPONSE,
SCI_FAILURE_IO_RESPONSE_VALID
);
sci_base_state_machine_change_state(
- &this_request->started_substate_machine,
+ &sci_req->started_substate_machine,
SCIC_SDS_STP_PACKET_REQUEST_STARTED_COMMAND_PHASE_AWAIT_D2H_FIS_SUBSTATE
);
}
/**
* This method processes an unsolicited frame.
- * @this_request: This parameter specifies the request for which the
+ * @sci_req: This parameter specifies the request for which the
* unsolicited frame was received.
* @frame_index: This parameter indicates the unsolicited frame index that
* should contain the response.
enum sci_status status;
struct sata_fis_header *frame_header;
u32 *frame_buffer;
- struct scic_sds_stp_request *this_request;
+ struct scic_sds_stp_request *sci_req;
- this_request = (struct scic_sds_stp_request *)request;
+ sci_req = (struct scic_sds_stp_request *)request;
status = scic_sds_unsolicited_frame_control_get_header(
- &(this_request->parent.owning_controller->uf_control),
+ &(sci_req->parent.owning_controller->uf_control),
frame_index,
(void **)&frame_header
);
* Get from the frame buffer the PIO Setup Data, although we don't need
* any info from this pio setup fis. */
scic_sds_unsolicited_frame_control_get_buffer(
- &(this_request->parent.owning_controller->uf_control),
+ &(sci_req->parent.owning_controller->uf_control),
frame_index,
(void **)&frame_buffer
);
scic_sds_controller_copy_sata_response(
- &this_request->d2h_reg_fis, (u32 *)frame_header, frame_buffer
+ &sci_req->d2h_reg_fis, (u32 *)frame_header, frame_buffer
);
/* Frame has been decoded return it to the controller */
scic_sds_controller_release_frame(
- this_request->parent.owning_controller, frame_index
+ sci_req->parent.owning_controller, frame_index
);
}
/**
* This method processes an unsolicited frame while the packet request is
* expecting TC completion. It will process the FIS and construct sense data.
- * @this_request: This parameter specifies the request for which the
+ * @sci_req: This parameter specifies the request for which the
* unsolicited frame was received.
* @frame_index: This parameter indicates the unsolicited frame index that
* should contain the response.
struct scic_sds_request *request,
u32 frame_index)
{
- struct scic_sds_stp_request *this_request = (struct scic_sds_stp_request *)request;
+ struct scic_sds_stp_request *sci_req = (struct scic_sds_stp_request *)request;
enum sci_status status =
scic_sds_stp_packet_request_command_phase_common_frame_handler(
if (status == SCI_SUCCESS) {
/* The command has completed with error status from target device. */
status = scic_sds_stp_packet_request_process_status_fis(
- request, &this_request->d2h_reg_fis);
+ request, &sci_req->d2h_reg_fis);
if (status != SCI_SUCCESS) {
scic_sds_request_set_status(
- &this_request->parent,
+ &sci_req->parent,
SCU_TASK_DONE_CHECK_RESPONSE,
status
);
} else
scic_sds_request_set_status(
- &this_request->parent, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+ &sci_req->parent, SCU_TASK_DONE_GOOD, SCI_SUCCESS
);
}
/**
* This method processes an unsolicited frame while the packet request is
* expecting TC completion. It will process the FIS and construct sense data.
- * @this_request: This parameter specifies the request for which the
+ * @sci_req: This parameter specifies the request for which the
* unsolicited frame was received.
* @frame_index: This parameter indicates the unsolicited frame index that
* should contain the response.
scic_sds_stp_packet_request_command_phase_common_frame_handler(
request, frame_index);
- struct scic_sds_stp_request *this_request = (struct scic_sds_stp_request *)request;
+ struct scic_sds_stp_request *sci_req = (struct scic_sds_stp_request *)request;
if (status == SCI_SUCCESS) {
/* The command has completed with error status from target device. */
status = scic_sds_stp_packet_request_process_status_fis(
- request, &this_request->d2h_reg_fis);
+ request, &sci_req->d2h_reg_fis);
if (status != SCI_SUCCESS) {
scic_sds_request_set_status(
void scic_sds_stp_packet_request_started_packet_phase_await_tc_completion_enter(
struct sci_base_object *object)
{
- struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+ struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
SET_STATE_HANDLER(
- this_request,
+ sci_req,
scic_sds_stp_packet_request_started_substate_handler_table,
SCIC_SDS_STP_PACKET_REQUEST_STARTED_PACKET_PHASE_AWAIT_TC_COMPLETION_SUBSTATE
);
scic_sds_remote_device_set_working_request(
- this_request->target_device, this_request
+ sci_req->target_device, sci_req
);
}
void scic_sds_stp_packet_request_started_packet_phase_await_pio_setup_enter(
struct sci_base_object *object)
{
- struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+ struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
SET_STATE_HANDLER(
- this_request,
+ sci_req,
scic_sds_stp_packet_request_started_substate_handler_table,
SCIC_SDS_STP_PACKET_REQUEST_STARTED_PACKET_PHASE_AWAIT_PIO_SETUP_SUBSTATE
);
void scic_sds_stp_packet_request_started_command_phase_await_tc_completion_enter(
struct sci_base_object *object)
{
- struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+ struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
u8 sat_packet_protocol =
- scic_cb_request_get_sat_protocol(this_request->user_request);
+ scic_cb_request_get_sat_protocol(sci_req->user_request);
struct scu_task_context *task_context;
enum sci_status status;
* Recycle the TC and reconstruct it for sending out data fis containing
* CDB. */
task_context = scic_sds_controller_get_task_context_buffer(
- this_request->owning_controller, this_request->io_tag);
+ sci_req->owning_controller, sci_req->io_tag);
if (sat_packet_protocol == SAT_PROTOCOL_PACKET_NON_DATA)
scu_stp_packet_request_command_phase_reconstruct_raw_frame_task_context(
- this_request, task_context);
+ sci_req, task_context);
else
scu_stp_packet_request_command_phase_construct_task_context(
- this_request, task_context);
+ sci_req, task_context);
/* send the new TC out. */
- status = this_request->owning_controller->state_handlers->parent.continue_io_handler(
- &this_request->owning_controller->parent,
- &this_request->target_device->parent,
- &this_request->parent
+ status = sci_req->owning_controller->state_handlers->parent.continue_io_handler(
+ &sci_req->owning_controller->parent,
+ &sci_req->target_device->parent,
+ &sci_req->parent
);
if (status == SCI_SUCCESS)
SET_STATE_HANDLER(
- this_request,
+ sci_req,
scic_sds_stp_packet_request_started_substate_handler_table,
SCIC_SDS_STP_PACKET_REQUEST_STARTED_COMMAND_PHASE_AWAIT_TC_COMPLETION_SUBSTATE
);
void scic_sds_stp_packet_request_started_command_phase_await_d2h_fis_enter(
struct sci_base_object *object)
{
- struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+ struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
SET_STATE_HANDLER(
- this_request,
+ sci_req,
scic_sds_stp_packet_request_started_substate_handler_table,
SCIC_SDS_STP_PACKET_REQUEST_STARTED_COMMAND_PHASE_AWAIT_D2H_FIS_SUBSTATE
);
void scic_sds_stp_packet_request_started_completion_delay_enter(
struct sci_base_object *object)
{
- struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+ struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
SET_STATE_HANDLER(
- this_request,
+ sci_req,
scic_sds_stp_packet_request_started_substate_handler_table,
SCIC_SDS_STP_PACKET_REQUEST_STARTED_COMPLETION_DELAY_SUBSTATE
);
#if !defined(DISABLE_ATAPI)
enum sci_status scic_sds_stp_packet_request_construct(
- struct scic_sds_request *this_request);
+ struct scic_sds_request *sci_req);
#else /* !defined(DISABLE_ATAPI) */
#define scic_sds_stp_packet_request_construct(request) SCI_FAILURE
#endif /* !defined(DISABLE_ATAPI) */
#if !defined(DISABLE_ATAPI)
void scu_stp_packet_request_command_phase_construct_task_context(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
struct scu_task_context *task_context);
#else /* !defined(DISABLE_ATAPI) */
#define scu_stp_packet_request_command_phase_construct_task_context(reqeust, tc)
#if !defined(DISABLE_ATAPI)
void scu_stp_packet_request_command_phase_reconstruct_raw_frame_task_context(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
struct scu_task_context *task_context);
#else /* !defined(DISABLE_ATAPI) */
#define scu_stp_packet_request_command_phase_reconstruct_raw_frame_task_context(reqeust, tc)
#if !defined(DISABLE_ATAPI)
enum sci_status scic_sds_stp_packet_request_process_status_fis(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
struct sata_fis_reg_d2h *status_fis);
#else /* !defined(DISABLE_ATAPI) */
#define scic_sds_stp_packet_request_process_status_fis(reqeust, fis) SCI_FAILURE
#if !defined(DISABLE_ATAPI)
void scic_sds_stp_packet_internal_request_sense_build_sgl(
- struct scic_sds_request *this_request);
+ struct scic_sds_request *sci_req);
#else /* !defined(DISABLE_ATAPI) */
#define scic_sds_stp_packet_internal_request_sense_build_sgl(request)
#endif /* !defined(DISABLE_ATAPI) */
* resume the RNC right away. enum sci_status
*/
static enum sci_status scic_sds_stp_remote_device_ready_idle_substate_event_handler(
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
u32 event_code)
{
enum sci_status status;
- status = scic_sds_remote_device_general_event_handler(this_device, event_code);
+ status = scic_sds_remote_device_general_event_handler(sci_dev, event_code);
if (status == SCI_SUCCESS) {
if (scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX
|| scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX) {
status = scic_sds_remote_node_context_resume(
- this_device->rnc, NULL, NULL);
+ sci_dev->rnc, NULL, NULL);
}
}
/**
* This method will handle events received while the STP device is in the ready
* command substate.
- * @this_device: This is the device object that is receiving the event.
+ * @sci_dev: This is the device object that is receiving the event.
* @event_code: The event code to process.
*
* enum sci_status
*/
static enum sci_status scic_sds_stp_remote_device_ready_ncq_substate_frame_handler(
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
u32 frame_index)
{
enum sci_status status;
struct sata_fis_header *frame_header;
status = scic_sds_unsolicited_frame_control_get_header(
- &(scic_sds_remote_device_get_controller(this_device)->uf_control),
+ &(scic_sds_remote_device_get_controller(sci_dev)->uf_control),
frame_index,
(void **)&frame_header
);
if (status == SCI_SUCCESS) {
if (frame_header->fis_type == SATA_FIS_TYPE_SETDEVBITS &&
(frame_header->status & ATA_STATUS_REG_ERROR_BIT)) {
- this_device->not_ready_reason =
+ sci_dev->not_ready_reason =
SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED;
/*
*/
sci_base_state_machine_change_state(
- &this_device->ready_substate_machine,
+ &sci_dev->ready_substate_machine,
SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR
);
} else if (frame_header->fis_type == SATA_FIS_TYPE_REGD2H &&
* Some devices return D2H FIS when an NCQ error is detected.
* Treat this like an SDB error FIS ready reason.
*/
- this_device->not_ready_reason =
+ sci_dev->not_ready_reason =
SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED;
sci_base_state_machine_change_state(
- &this_device->ready_substate_machine,
+ &sci_dev->ready_substate_machine,
SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR
);
} else {
}
scic_sds_controller_release_frame(
- scic_sds_remote_device_get_controller(this_device), frame_index
+ scic_sds_remote_device_get_controller(sci_dev), frame_index
);
}
}
static enum sci_status scic_sds_stp_remote_device_ready_cmd_substate_suspend_handler(
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
u32 suspend_type)
{
enum sci_status status;
status = scic_sds_remote_node_context_suspend(
- this_device->rnc, suspend_type, NULL, NULL
+ sci_dev->rnc, suspend_type, NULL, NULL
);
return status;
}
static enum sci_status scic_sds_stp_remote_device_ready_cmd_substate_frame_handler(
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
u32 frame_index)
{
enum sci_status status;
* / in this state. All unsolicited frames are forwarded to the io request
* / object. */
status = scic_sds_io_request_frame_handler(
- this_device->working_request,
+ sci_dev->working_request,
frame_index
);
struct scic_sds_remote_device *device,
struct scic_sds_request *request)
{
- struct scic_sds_request *the_request = (struct scic_sds_request *)request;
+ struct scic_sds_request *sci_req = (struct scic_sds_request *)request;
enum sci_status status;
- status = scic_sds_io_request_complete(the_request);
+ status = scic_sds_io_request_complete(sci_req);
if (status == SCI_SUCCESS) {
status = scic_sds_port_complete_io(
- device->owning_port, device, the_request
+ device->owning_port, device, sci_req
);
if (status == SCI_SUCCESS)
__func__,
device->owning_port,
device,
- the_request,
+ sci_req,
status);
return status;
* this device. enum sci_status
*/
enum sci_status scic_sds_stp_remote_device_ready_atapi_error_substate_event_handler(
- struct scic_sds_remote_device *this_device,
+ struct scic_sds_remote_device *sci_dev,
u32 event_code)
{
enum sci_status status;
- status = scic_sds_remote_device_general_event_handler(this_device, event_code);
+ status = scic_sds_remote_device_general_event_handler(sci_dev, event_code);
if (status == SCI_SUCCESS) {
if (scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX
|| scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX) {
status = scic_sds_remote_node_context_resume(
- this_device->rnc,
- this_device->working_request->state_handlers->parent.complete_handler,
- (void *)this_device->working_request
+ sci_dev->rnc,
+ sci_dev->working_request->state_handlers->parent.complete_handler,
+ (void *)sci_dev->working_request
);
}
}
static void scic_sds_stp_remote_device_ready_idle_substate_enter(
struct sci_base_object *device)
{
- struct scic_sds_remote_device *this_device;
+ struct scic_sds_remote_device *sci_dev;
- this_device = (struct scic_sds_remote_device *)device;
+ sci_dev = (struct scic_sds_remote_device *)device;
SET_STATE_HANDLER(
- this_device,
+ sci_dev,
scic_sds_stp_remote_device_ready_substate_handler_table,
SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE
);
- this_device->working_request = NULL;
+ sci_dev->working_request = NULL;
- if (scic_sds_remote_node_context_is_ready(this_device->rnc)) {
+ if (scic_sds_remote_node_context_is_ready(sci_dev->rnc)) {
/*
* Since the RNC is ready, it's alright to finish completion
* processing (e.g. signal the remote device is ready). */
scic_sds_stp_remote_device_ready_idle_substate_resume_complete_handler(
- this_device
+ sci_dev
);
} else {
scic_sds_remote_node_context_resume(
- this_device->rnc,
+ sci_dev->rnc,
scic_sds_stp_remote_device_ready_idle_substate_resume_complete_handler,
- this_device
+ sci_dev
);
}
}
static void scic_sds_stp_remote_device_ready_await_reset_substate_enter(
struct sci_base_object *device)
{
- struct scic_sds_remote_device *this_device;
+ struct scic_sds_remote_device *sci_dev;
- this_device = (struct scic_sds_remote_device *)device;
+ sci_dev = (struct scic_sds_remote_device *)device;
SET_STATE_HANDLER(
- this_device,
+ sci_dev,
scic_sds_stp_remote_device_ready_substate_handler_table,
SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET
);
void scic_sds_stp_remote_device_ready_atapi_error_substate_enter(
struct sci_base_object *device)
{
- struct scic_sds_remote_device *this_device;
+ struct scic_sds_remote_device *sci_dev;
- this_device = (struct scic_sds_remote_device *)device;
+ sci_dev = (struct scic_sds_remote_device *)device;
SET_STATE_HANDLER(
- this_device,
+ sci_dev,
scic_sds_stp_remote_device_ready_substate_handler_table,
SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_ATAPI_ERROR
);
/**
* This method is will fill in the SCU Task Context for any type of SATA
* request. This is called from the various SATA constructors.
- * @this_request: The general IO request object which is to be used in
+ * @sci_req: The general IO request object which is to be used in
* constructing the SCU task context.
* @task_context: The buffer pointer for the SCU task context which is being
* constructed.
/**
*
- * @this_request:
+ * @sci_req:
*
* This method will perform any general sata request construction. What part of
* SATA IO request construction is general? none
*/
static void scic_sds_stp_non_ncq_request_construct(
- struct scic_sds_request *this_request)
+ struct scic_sds_request *sci_req)
{
- this_request->has_started_substate_machine = true;
+ sci_req->has_started_substate_machine = true;
}
/**
/**
* scu_stp_raw_request_construct_task_context -
- * @this_request: This parameter specifies the STP request object for which to
+ * @sci_req: This parameter specifies the STP request object for which to
* construct a RAW command frame task context.
* @task_context: This parameter specifies the SCU specific task context buffer
* to construct.
* utilizing the raw frame method. none
*/
static void scu_stp_raw_request_construct_task_context(
- struct scic_sds_stp_request *this_request,
+ struct scic_sds_stp_request *sci_req,
struct scu_task_context *task_context)
{
- scu_sata_reqeust_construct_task_context(&this_request->parent, task_context);
+ scu_sata_reqeust_construct_task_context(&sci_req->parent, task_context);
task_context->control_frame = 0;
task_context->priority = SCU_TASK_PRIORITY_NORMAL;
/**
*
- * @this_request:
+ * @sci_req:
*
* Get the next SGL element from the request. - Check on which SGL element pair
* we are working - if working on SLG pair element A - advance to element B -
/**
*
- * @this_request:
+ * @sci_req:
* @completion_code:
*
* This method processes a TC completion. The expected TC completion is for
* SCI_SUCCESS This value is always returned.
*/
static enum sci_status scic_sds_stp_request_non_data_await_h2d_tc_completion_handler(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
u32 completion_code)
{
switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
scic_sds_request_set_status(
- this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+ sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
);
sci_base_state_machine_change_state(
- &this_request->started_substate_machine,
+ &sci_req->started_substate_machine,
SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_D2H_SUBSTATE
);
break;
* All other completion status cause the IO to be complete. If a NAK
* was received, then it is up to the user to retry the request. */
scic_sds_request_set_status(
- this_request,
+ sci_req,
SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
);
sci_base_state_machine_change_state(
- &this_request->state_machine, SCI_BASE_REQUEST_STATE_COMPLETED);
+ &sci_req->state_machine, SCI_BASE_REQUEST_STATE_COMPLETED);
break;
}
enum sci_status status;
struct sata_fis_header *frame_header;
u32 *frame_buffer;
- struct scic_sds_stp_request *this_request = (struct scic_sds_stp_request *)request;
+ struct scic_sds_stp_request *sci_req = (struct scic_sds_stp_request *)request;
status = scic_sds_unsolicited_frame_control_get_header(
- &this_request->parent.owning_controller->uf_control,
+ &sci_req->parent.owning_controller->uf_control,
frame_index,
(void **)&frame_header
);
switch (frame_header->fis_type) {
case SATA_FIS_TYPE_REGD2H:
scic_sds_unsolicited_frame_control_get_buffer(
- &this_request->parent.owning_controller->uf_control,
+ &sci_req->parent.owning_controller->uf_control,
frame_index,
(void **)&frame_buffer
);
scic_sds_controller_copy_sata_response(
- &this_request->d2h_reg_fis, (u32 *)frame_header, frame_buffer
+ &sci_req->d2h_reg_fis, (u32 *)frame_header, frame_buffer
);
/* The command has completed with error */
scic_sds_request_set_status(
- &this_request->parent,
+ &sci_req->parent,
SCU_TASK_DONE_CHECK_RESPONSE,
SCI_FAILURE_IO_RESPONSE_VALID
);
dev_warn(scic_to_dev(request->owning_controller),
"%s: IO Request:0x%p Frame Id:%d protocol "
"violation occurred\n",
- __func__, this_request, frame_index);
+ __func__, sci_req, frame_index);
scic_sds_request_set_status(
- &this_request->parent,
+ &sci_req->parent,
SCU_TASK_DONE_UNEXP_FIS,
SCI_FAILURE_PROTOCOL_VIOLATION
);
}
sci_base_state_machine_change_state(
- &this_request->parent.state_machine,
+ &sci_req->parent.state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED
);
/* Frame has been decoded return it to the controller */
scic_sds_controller_release_frame(
- this_request->parent.owning_controller, frame_index);
+ sci_req->parent.owning_controller, frame_index);
} else
dev_err(scic_to_dev(request->owning_controller),
"%s: SCIC IO Request 0x%p could not get frame header "
"for frame index %d, status %x\n",
- __func__, this_request, frame_index, status);
+ __func__, sci_req, frame_index, status);
return status;
}
static void scic_sds_stp_request_started_non_data_await_h2d_completion_enter(
struct sci_base_object *object)
{
- struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+ struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
SET_STATE_HANDLER(
- this_request,
+ sci_req,
scic_sds_stp_request_started_non_data_substate_handler_table,
SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_H2D_COMPLETION_SUBSTATE
);
scic_sds_remote_device_set_working_request(
- this_request->target_device, this_request
+ sci_req->target_device, sci_req
);
}
static void scic_sds_stp_request_started_non_data_await_d2h_enter(
struct sci_base_object *object)
{
- struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+ struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
SET_STATE_HANDLER(
- this_request,
+ sci_req,
scic_sds_stp_request_started_non_data_substate_handler_table,
SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_D2H_SUBSTATE
);
/**
*
- * @this_request:
+ * @sci_req:
* @length:
*
* This function will transmit DATA_FIS from (current sgl + offset) for input
*/
static enum sci_status scic_sds_stp_request_pio_data_out_trasmit_data_frame(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
u32 length)
{
- struct scic_sds_stp_request *this_sds_stp_request = (struct scic_sds_stp_request *)this_request;
+ struct scic_sds_stp_request *stp_req = (struct scic_sds_stp_request *)sci_req;
struct scu_sgl_element *current_sgl;
/*
* Recycle the TC and reconstruct it for sending out DATA FIS containing
* for the data from current_sgl+offset for the input length */
struct scu_task_context *task_context = scic_sds_controller_get_task_context_buffer(
- this_request->owning_controller,
- this_request->io_tag
+ sci_req->owning_controller,
+ sci_req->io_tag
);
- if (this_sds_stp_request->type.pio.request_current.sgl_set == SCU_SGL_ELEMENT_PAIR_A)
- current_sgl = &(this_sds_stp_request->type.pio.request_current.sgl_pair->A);
+ if (stp_req->type.pio.request_current.sgl_set == SCU_SGL_ELEMENT_PAIR_A)
+ current_sgl = &(stp_req->type.pio.request_current.sgl_pair->A);
else
- current_sgl = &(this_sds_stp_request->type.pio.request_current.sgl_pair->B);
+ current_sgl = &(stp_req->type.pio.request_current.sgl_pair->B);
/* update the TC */
task_context->command_iu_upper = current_sgl->address_upper;
task_context->type.stp.fis_type = SATA_FIS_TYPE_DATA;
/* send the new TC out. */
- return scic_controller_continue_io(this_request);
+ return scic_controller_continue_io(sci_req);
}
/**
*
- * @this_request:
+ * @sci_req:
*
* enum sci_status
*/
static enum sci_status scic_sds_stp_request_pio_data_out_transmit_data(
- struct scic_sds_request *this_sds_request)
+ struct scic_sds_request *sci_req)
{
struct scu_sgl_element *current_sgl;
u32 remaining_bytes_in_current_sgl = 0;
enum sci_status status = SCI_SUCCESS;
- struct scic_sds_stp_request *this_sds_stp_request = (struct scic_sds_stp_request *)this_sds_request;
+ struct scic_sds_stp_request *stp_req = (struct scic_sds_stp_request *)sci_req;
- sgl_offset = this_sds_stp_request->type.pio.request_current.sgl_offset;
+ sgl_offset = stp_req->type.pio.request_current.sgl_offset;
- if (this_sds_stp_request->type.pio.request_current.sgl_set == SCU_SGL_ELEMENT_PAIR_A) {
- current_sgl = &(this_sds_stp_request->type.pio.request_current.sgl_pair->A);
- remaining_bytes_in_current_sgl = this_sds_stp_request->type.pio.request_current.sgl_pair->A.length - sgl_offset;
+ if (stp_req->type.pio.request_current.sgl_set == SCU_SGL_ELEMENT_PAIR_A) {
+ current_sgl = &(stp_req->type.pio.request_current.sgl_pair->A);
+ remaining_bytes_in_current_sgl = stp_req->type.pio.request_current.sgl_pair->A.length - sgl_offset;
} else {
- current_sgl = &(this_sds_stp_request->type.pio.request_current.sgl_pair->B);
- remaining_bytes_in_current_sgl = this_sds_stp_request->type.pio.request_current.sgl_pair->B.length - sgl_offset;
+ current_sgl = &(stp_req->type.pio.request_current.sgl_pair->B);
+ remaining_bytes_in_current_sgl = stp_req->type.pio.request_current.sgl_pair->B.length - sgl_offset;
}
- if (this_sds_stp_request->type.pio.pio_transfer_bytes > 0) {
- if (this_sds_stp_request->type.pio.pio_transfer_bytes >= remaining_bytes_in_current_sgl) {
+ if (stp_req->type.pio.pio_transfer_bytes > 0) {
+ if (stp_req->type.pio.pio_transfer_bytes >= remaining_bytes_in_current_sgl) {
/* recycle the TC and send the H2D Data FIS from (current sgl + sgl_offset) and length = remaining_bytes_in_current_sgl */
- status = scic_sds_stp_request_pio_data_out_trasmit_data_frame(this_sds_request, remaining_bytes_in_current_sgl);
+ status = scic_sds_stp_request_pio_data_out_trasmit_data_frame(sci_req, remaining_bytes_in_current_sgl);
if (status == SCI_SUCCESS) {
- this_sds_stp_request->type.pio.pio_transfer_bytes -= remaining_bytes_in_current_sgl;
+ stp_req->type.pio.pio_transfer_bytes -= remaining_bytes_in_current_sgl;
/* update the current sgl, sgl_offset and save for future */
- current_sgl = scic_sds_stp_request_pio_get_next_sgl(this_sds_stp_request);
+ current_sgl = scic_sds_stp_request_pio_get_next_sgl(stp_req);
sgl_offset = 0;
}
- } else if (this_sds_stp_request->type.pio.pio_transfer_bytes < remaining_bytes_in_current_sgl) {
+ } else if (stp_req->type.pio.pio_transfer_bytes < remaining_bytes_in_current_sgl) {
/* recycle the TC and send the H2D Data FIS from (current sgl + sgl_offset) and length = type.pio.pio_transfer_bytes */
- scic_sds_stp_request_pio_data_out_trasmit_data_frame(this_sds_request, this_sds_stp_request->type.pio.pio_transfer_bytes);
+ scic_sds_stp_request_pio_data_out_trasmit_data_frame(sci_req, stp_req->type.pio.pio_transfer_bytes);
if (status == SCI_SUCCESS) {
/* Sgl offset will be adjusted and saved for future */
- sgl_offset += this_sds_stp_request->type.pio.pio_transfer_bytes;
- current_sgl->address_lower += this_sds_stp_request->type.pio.pio_transfer_bytes;
- this_sds_stp_request->type.pio.pio_transfer_bytes = 0;
+ sgl_offset += stp_req->type.pio.pio_transfer_bytes;
+ current_sgl->address_lower += stp_req->type.pio.pio_transfer_bytes;
+ stp_req->type.pio.pio_transfer_bytes = 0;
}
}
}
if (status == SCI_SUCCESS) {
- this_sds_stp_request->type.pio.request_current.sgl_offset = sgl_offset;
+ stp_req->type.pio.request_current.sgl_offset = sgl_offset;
}
return status;
/**
*
- * @this_request: The PIO DATA IN request that is to receive the data.
+ * @sci_req: The PIO DATA IN request that is to receive the data.
* @data_buffer: The buffer to copy from.
*
* Copy the data buffer to the io request data region. enum sci_status
*/
static enum sci_status scic_sds_stp_request_pio_data_in_copy_data(
- struct scic_sds_stp_request *this_request,
+ struct scic_sds_stp_request *sci_req,
u8 *data_buffer)
{
enum sci_status status;
/*
* If there is less than 1K remaining in the transfer request
* copy just the data for the transfer */
- if (this_request->type.pio.pio_transfer_bytes < SCU_MAX_FRAME_BUFFER_SIZE) {
+ if (sci_req->type.pio.pio_transfer_bytes < SCU_MAX_FRAME_BUFFER_SIZE) {
status = scic_sds_stp_request_pio_data_in_copy_data_buffer(
- this_request, data_buffer, this_request->type.pio.pio_transfer_bytes);
+ sci_req, data_buffer, sci_req->type.pio.pio_transfer_bytes);
if (status == SCI_SUCCESS)
- this_request->type.pio.pio_transfer_bytes = 0;
+ sci_req->type.pio.pio_transfer_bytes = 0;
} else {
/* We are transfering the whole frame so copy */
status = scic_sds_stp_request_pio_data_in_copy_data_buffer(
- this_request, data_buffer, SCU_MAX_FRAME_BUFFER_SIZE);
+ sci_req, data_buffer, SCU_MAX_FRAME_BUFFER_SIZE);
if (status == SCI_SUCCESS)
- this_request->type.pio.pio_transfer_bytes -= SCU_MAX_FRAME_BUFFER_SIZE;
+ sci_req->type.pio.pio_transfer_bytes -= SCU_MAX_FRAME_BUFFER_SIZE;
}
return status;
/**
*
- * @this_request:
+ * @sci_req:
* @completion_code:
*
* enum sci_status
*/
static enum sci_status scic_sds_stp_request_pio_await_h2d_completion_tc_completion_handler(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
u32 completion_code)
{
enum sci_status status = SCI_SUCCESS;
switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
scic_sds_request_set_status(
- this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+ sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
);
sci_base_state_machine_change_state(
- &this_request->started_substate_machine,
+ &sci_req->started_substate_machine,
SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE
);
break;
* All other completion status cause the IO to be complete. If a NAK
* was received, then it is up to the user to retry the request. */
scic_sds_request_set_status(
- this_request,
+ sci_req,
SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
);
sci_base_state_machine_change_state(
- &this_request->state_machine,
+ &sci_req->state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED
);
break;
/**
*
- * @this_request:
+ * @sci_req:
* @frame_index:
*
* enum sci_status
enum sci_status status;
struct sata_fis_header *frame_header;
u32 *frame_buffer;
- struct scic_sds_stp_request *this_request;
+ struct scic_sds_stp_request *sci_req;
- this_request = (struct scic_sds_stp_request *)request;
+ sci_req = (struct scic_sds_stp_request *)request;
status = scic_sds_unsolicited_frame_control_get_header(
- &(this_request->parent.owning_controller->uf_control),
+ &(sci_req->parent.owning_controller->uf_control),
frame_index,
(void **)&frame_header
);
case SATA_FIS_TYPE_PIO_SETUP:
/* Get from the frame buffer the PIO Setup Data */
scic_sds_unsolicited_frame_control_get_buffer(
- &(this_request->parent.owning_controller->uf_control),
+ &(sci_req->parent.owning_controller->uf_control),
frame_index,
(void **)&frame_buffer
);
* Get the data from the PIO Setup
* The SCU Hardware returns first word in the frame_header and the rest
* of the data is in the frame buffer so we need to back up one dword */
- this_request->type.pio.pio_transfer_bytes =
+ sci_req->type.pio.pio_transfer_bytes =
(u16)((struct sata_fis_pio_setup *)(&frame_buffer[-1]))->transfter_count;
- this_request->type.pio.ending_status =
+ sci_req->type.pio.ending_status =
(u8)((struct sata_fis_pio_setup *)(&frame_buffer[-1]))->ending_status;
scic_sds_controller_copy_sata_response(
- &this_request->d2h_reg_fis, (u32 *)frame_header, frame_buffer
+ &sci_req->d2h_reg_fis, (u32 *)frame_header, frame_buffer
);
- this_request->d2h_reg_fis.status =
- this_request->type.pio.ending_status;
+ sci_req->d2h_reg_fis.status =
+ sci_req->type.pio.ending_status;
/* The next state is dependent on whether the request was PIO Data-in or Data out */
- if (this_request->type.pio.sat_protocol == SAT_PROTOCOL_PIO_DATA_IN) {
+ if (sci_req->type.pio.sat_protocol == SAT_PROTOCOL_PIO_DATA_IN) {
sci_base_state_machine_change_state(
- &this_request->parent.started_substate_machine,
+ &sci_req->parent.started_substate_machine,
SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_IN_AWAIT_DATA_SUBSTATE
);
- } else if (this_request->type.pio.sat_protocol == SAT_PROTOCOL_PIO_DATA_OUT) {
+ } else if (sci_req->type.pio.sat_protocol == SAT_PROTOCOL_PIO_DATA_OUT) {
/* Transmit data */
status = scic_sds_stp_request_pio_data_out_transmit_data(request);
if (status == SCI_SUCCESS) {
sci_base_state_machine_change_state(
- &this_request->parent.started_substate_machine,
+ &sci_req->parent.started_substate_machine,
SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_OUT_TRANSMIT_DATA_SUBSTATE
);
}
case SATA_FIS_TYPE_SETDEVBITS:
sci_base_state_machine_change_state(
- &this_request->parent.started_substate_machine,
+ &sci_req->parent.started_substate_machine,
SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE
);
break;
case SATA_FIS_TYPE_REGD2H:
if ((frame_header->status & ATA_STATUS_REG_BSY_BIT) == 0) {
scic_sds_unsolicited_frame_control_get_buffer(
- &(this_request->parent.owning_controller->uf_control),
+ &(sci_req->parent.owning_controller->uf_control),
frame_index,
(void **)&frame_buffer
);
scic_sds_controller_copy_sata_response(
- &this_request->d2h_reg_fis, (u32 *)frame_header, frame_buffer);
+ &sci_req->d2h_reg_fis, (u32 *)frame_header, frame_buffer);
scic_sds_request_set_status(
- &this_request->parent,
+ &sci_req->parent,
SCU_TASK_DONE_CHECK_RESPONSE,
SCI_FAILURE_IO_RESPONSE_VALID
);
sci_base_state_machine_change_state(
- &this_request->parent.state_machine,
+ &sci_req->parent.state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED
);
} else {
"D2H Register FIS with BSY status "
"0x%x\n",
__func__,
- this_request,
+ sci_req,
frame_header->status);
}
break;
/* Frame is decoded return it to the controller */
scic_sds_controller_release_frame(
- this_request->parent.owning_controller,
+ sci_req->parent.owning_controller,
frame_index
);
} else
dev_err(scic_to_dev(request->owning_controller),
"%s: SCIC IO Request 0x%p could not get frame header "
"for frame index %d, status %x\n",
- __func__, this_request, frame_index, status);
+ __func__, sci_req, frame_index, status);
return status;
}
/**
*
- * @this_request:
+ * @sci_req:
* @frame_index:
*
* enum sci_status
enum sci_status status;
struct sata_fis_header *frame_header;
struct sata_fis_data *frame_buffer;
- struct scic_sds_stp_request *this_request;
+ struct scic_sds_stp_request *sci_req;
- this_request = (struct scic_sds_stp_request *)request;
+ sci_req = (struct scic_sds_stp_request *)request;
status = scic_sds_unsolicited_frame_control_get_header(
- &(this_request->parent.owning_controller->uf_control),
+ &(sci_req->parent.owning_controller->uf_control),
frame_index,
(void **)&frame_header
);
if (status == SCI_SUCCESS) {
if (frame_header->fis_type == SATA_FIS_TYPE_DATA) {
- if (this_request->type.pio.request_current.sgl_pair == NULL) {
- this_request->parent.saved_rx_frame_index = frame_index;
- this_request->type.pio.pio_transfer_bytes = 0;
+ if (sci_req->type.pio.request_current.sgl_pair == NULL) {
+ sci_req->parent.saved_rx_frame_index = frame_index;
+ sci_req->type.pio.pio_transfer_bytes = 0;
} else {
status = scic_sds_unsolicited_frame_control_get_buffer(
- &(this_request->parent.owning_controller->uf_control),
+ &(sci_req->parent.owning_controller->uf_control),
frame_index,
(void **)&frame_buffer
);
- status = scic_sds_stp_request_pio_data_in_copy_data(this_request, (u8 *)frame_buffer);
+ status = scic_sds_stp_request_pio_data_in_copy_data(sci_req, (u8 *)frame_buffer);
/* Frame is decoded return it to the controller */
scic_sds_controller_release_frame(
- this_request->parent.owning_controller,
+ sci_req->parent.owning_controller,
frame_index
);
}
* for this data transfer */
if (
(status == SCI_SUCCESS)
- && (this_request->type.pio.pio_transfer_bytes == 0)
+ && (sci_req->type.pio.pio_transfer_bytes == 0)
) {
- if ((this_request->type.pio.ending_status & ATA_STATUS_REG_BSY_BIT) == 0) {
+ if ((sci_req->type.pio.ending_status & ATA_STATUS_REG_BSY_BIT) == 0) {
scic_sds_request_set_status(
- &this_request->parent,
+ &sci_req->parent,
SCU_TASK_DONE_CHECK_RESPONSE,
SCI_FAILURE_IO_RESPONSE_VALID
);
sci_base_state_machine_change_state(
- &this_request->parent.state_machine,
+ &sci_req->parent.state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED
);
} else {
"with fis type 0x%02x when expecting a data "
"fis.\n",
__func__,
- this_request,
+ sci_req,
frame_index,
frame_header->fis_type);
scic_sds_request_set_status(
- &this_request->parent,
+ &sci_req->parent,
SCU_TASK_DONE_GOOD,
SCI_FAILURE_IO_REQUIRES_SCSI_ABORT
);
sci_base_state_machine_change_state(
- &this_request->parent.state_machine,
+ &sci_req->parent.state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED
);
/* Frame is decoded return it to the controller */
scic_sds_controller_release_frame(
- this_request->parent.owning_controller,
+ sci_req->parent.owning_controller,
frame_index
);
}
dev_err(scic_to_dev(request->owning_controller),
"%s: SCIC IO Request 0x%p could not get frame header "
"for frame index %d, status %x\n",
- __func__, this_request, frame_index, status);
+ __func__, sci_req, frame_index, status);
return status;
}
/**
*
- * @this_request:
+ * @sci_req:
* @completion_code:
*
* enum sci_status
*/
static enum sci_status scic_sds_stp_request_pio_data_out_await_data_transmit_completion_tc_completion_handler(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
u32 completion_code)
{
enum sci_status status = SCI_SUCCESS;
bool all_frames_transferred = false;
- struct scic_sds_stp_request *this_scic_sds_stp_request = (struct scic_sds_stp_request *)this_request;
+ struct scic_sds_stp_request *stp_req = (struct scic_sds_stp_request *)sci_req;
switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
/* Transmit data */
- if (this_scic_sds_stp_request->type.pio.pio_transfer_bytes != 0) {
- status = scic_sds_stp_request_pio_data_out_transmit_data(this_request);
+ if (stp_req->type.pio.pio_transfer_bytes != 0) {
+ status = scic_sds_stp_request_pio_data_out_transmit_data(sci_req);
if (status == SCI_SUCCESS) {
- if (this_scic_sds_stp_request->type.pio.pio_transfer_bytes == 0)
+ if (stp_req->type.pio.pio_transfer_bytes == 0)
all_frames_transferred = true;
}
- } else if (this_scic_sds_stp_request->type.pio.pio_transfer_bytes == 0) {
+ } else if (stp_req->type.pio.pio_transfer_bytes == 0) {
/*
* this will happen if the all data is written at the
* first time after the pio setup fis is received
* Change the state to SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_IN_AWAIT_FRAME_SUBSTATE
* and wait for PIO_SETUP fis / or D2H REg fis. */
sci_base_state_machine_change_state(
- &this_request->started_substate_machine,
+ &sci_req->started_substate_machine,
SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE
);
}
* All other completion status cause the IO to be complete. If a NAK
* was received, then it is up to the user to retry the request. */
scic_sds_request_set_status(
- this_request,
+ sci_req,
SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
);
sci_base_state_machine_change_state(
- &this_request->state_machine,
+ &sci_req->state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED
);
break;
static void scic_sds_stp_request_started_pio_await_h2d_completion_enter(
struct sci_base_object *object)
{
- struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+ struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
SET_STATE_HANDLER(
- this_request,
+ sci_req,
scic_sds_stp_request_started_pio_substate_handler_table,
SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_H2D_COMPLETION_SUBSTATE
);
scic_sds_remote_device_set_working_request(
- this_request->target_device, this_request);
+ sci_req->target_device, sci_req);
}
static void scic_sds_stp_request_started_pio_await_frame_enter(
struct sci_base_object *object)
{
- struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+ struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
SET_STATE_HANDLER(
- this_request,
+ sci_req,
scic_sds_stp_request_started_pio_substate_handler_table,
SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE
);
static void scic_sds_stp_request_started_pio_data_in_await_data_enter(
struct sci_base_object *object)
{
- struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+ struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
SET_STATE_HANDLER(
- this_request,
+ sci_req,
scic_sds_stp_request_started_pio_substate_handler_table,
SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_IN_AWAIT_DATA_SUBSTATE
);
static void scic_sds_stp_request_started_pio_data_out_transmit_data_enter(
struct sci_base_object *object)
{
- struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+ struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
SET_STATE_HANDLER(
- this_request,
+ sci_req,
scic_sds_stp_request_started_pio_substate_handler_table,
SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_OUT_TRANSMIT_DATA_SUBSTATE
);
/**
*
- * @this_request:
+ * @sci_req:
* @frame_index:
*
* enum sci_status
*/
static enum sci_status scic_sds_stp_request_udma_general_frame_handler(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
u32 frame_index)
{
enum sci_status status;
u32 *frame_buffer;
status = scic_sds_unsolicited_frame_control_get_header(
- &this_request->owning_controller->uf_control,
+ &sci_req->owning_controller->uf_control,
frame_index,
(void **)&frame_header
);
&& (frame_header->fis_type == SATA_FIS_TYPE_REGD2H)
) {
scic_sds_unsolicited_frame_control_get_buffer(
- &this_request->owning_controller->uf_control,
+ &sci_req->owning_controller->uf_control,
frame_index,
(void **)&frame_buffer
);
scic_sds_controller_copy_sata_response(
- &((struct scic_sds_stp_request *)this_request)->d2h_reg_fis,
+ &((struct scic_sds_stp_request *)sci_req)->d2h_reg_fis,
(u32 *)frame_header,
frame_buffer
);
}
scic_sds_controller_release_frame(
- this_request->owning_controller, frame_index);
+ sci_req->owning_controller, frame_index);
return status;
}
/**
* This method process TC completions while in the state where we are waiting
* for TC completions.
- * @this_request:
+ * @sci_req:
* @completion_code:
*
* enum sci_status
u32 completion_code)
{
enum sci_status status = SCI_SUCCESS;
- struct scic_sds_stp_request *this_request = (struct scic_sds_stp_request *)request;
+ struct scic_sds_stp_request *sci_req = (struct scic_sds_stp_request *)request;
switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
scic_sds_stp_request_udma_complete_request(
- &this_request->parent, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+ &sci_req->parent, SCU_TASK_DONE_GOOD, SCI_SUCCESS
);
break;
/*
* We must check ther response buffer to see if the D2H Register FIS was
* received before we got the TC completion. */
- if (this_request->d2h_reg_fis.fis_type == SATA_FIS_TYPE_REGD2H) {
+ if (sci_req->d2h_reg_fis.fis_type == SATA_FIS_TYPE_REGD2H) {
scic_sds_remote_device_suspend(
- this_request->parent.target_device,
+ sci_req->parent.target_device,
SCU_EVENT_SPECIFIC(SCU_NORMALIZE_COMPLETION_STATUS(completion_code))
);
scic_sds_stp_request_udma_complete_request(
- &this_request->parent,
+ &sci_req->parent,
SCU_TASK_DONE_CHECK_RESPONSE,
SCI_FAILURE_IO_RESPONSE_VALID
);
* If we have an error completion status for the TC then we can expect a
* D2H register FIS from the device so we must change state to wait for it */
sci_base_state_machine_change_state(
- &this_request->parent.started_substate_machine,
+ &sci_req->parent.started_substate_machine,
SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_D2H_REG_FIS_SUBSTATE
);
}
case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_CMD_LL_R_ERR):
case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_CRC_ERR):
scic_sds_remote_device_suspend(
- this_request->parent.target_device,
+ sci_req->parent.target_device,
SCU_EVENT_SPECIFIC(SCU_NORMALIZE_COMPLETION_STATUS(completion_code))
);
/* Fall through to the default case */
default:
/* All other completion status cause the IO to be complete. */
scic_sds_stp_request_udma_complete_request(
- &this_request->parent,
+ &sci_req->parent,
SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
);
}
static enum sci_status scic_sds_stp_request_udma_await_d2h_reg_fis_frame_handler(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
u32 frame_index)
{
enum sci_status status;
/* Use the general frame handler to copy the resposne data */
- status = scic_sds_stp_request_udma_general_frame_handler(this_request, frame_index);
+ status = scic_sds_stp_request_udma_general_frame_handler(sci_req, frame_index);
if (status == SCI_SUCCESS) {
scic_sds_stp_request_udma_complete_request(
- this_request,
+ sci_req,
SCU_TASK_DONE_CHECK_RESPONSE,
SCI_FAILURE_IO_RESPONSE_VALID
);
static void scic_sds_stp_request_started_udma_await_tc_completion_enter(
struct sci_base_object *object)
{
- struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+ struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
SET_STATE_HANDLER(
- this_request,
+ sci_req,
scic_sds_stp_request_started_udma_substate_handler_table,
SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_TC_COMPLETION_SUBSTATE
);
static void scic_sds_stp_request_started_udma_await_d2h_reg_fis_enter(
struct sci_base_object *object)
{
- struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+ struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
SET_STATE_HANDLER(
- this_request,
+ sci_req,
scic_sds_stp_request_started_udma_substate_handler_table,
SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_D2H_REG_FIS_SUBSTATE
);
/**
*
- * @this_request:
+ * @sci_req:
* @completion_code:
*
* This method processes a TC completion. The expected TC completion is for
* SCI_SUCCESS This value is always returned.
*/
static enum sci_status scic_sds_stp_request_soft_reset_await_h2d_asserted_tc_completion_handler(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
u32 completion_code)
{
switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
scic_sds_request_set_status(
- this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+ sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
);
sci_base_state_machine_change_state(
- &this_request->started_substate_machine,
+ &sci_req->started_substate_machine,
SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_DIAGNOSTIC_COMPLETION_SUBSTATE
);
break;
* All other completion status cause the IO to be complete. If a NAK
* was received, then it is up to the user to retry the request. */
scic_sds_request_set_status(
- this_request,
+ sci_req,
SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
);
sci_base_state_machine_change_state(
- &this_request->state_machine, SCI_BASE_REQUEST_STATE_COMPLETED);
+ &sci_req->state_machine, SCI_BASE_REQUEST_STATE_COMPLETED);
break;
}
/**
*
- * @this_request:
+ * @sci_req:
* @completion_code:
*
* This method processes a TC completion. The expected TC completion is for
* SCI_SUCCESS This value is always returned.
*/
static enum sci_status scic_sds_stp_request_soft_reset_await_h2d_diagnostic_tc_completion_handler(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
u32 completion_code)
{
switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
scic_sds_request_set_status(
- this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+ sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
);
sci_base_state_machine_change_state(
- &this_request->started_substate_machine,
+ &sci_req->started_substate_machine,
SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_D2H_RESPONSE_FRAME_SUBSTATE
);
break;
* All other completion status cause the IO to be complete. If a NAK
* was received, then it is up to the user to retry the request. */
scic_sds_request_set_status(
- this_request,
+ sci_req,
SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
);
- sci_base_state_machine_change_state(&this_request->state_machine,
+ sci_base_state_machine_change_state(&sci_req->state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED);
break;
}
enum sci_status status;
struct sata_fis_header *frame_header;
u32 *frame_buffer;
- struct scic_sds_stp_request *this_request = (struct scic_sds_stp_request *)request;
+ struct scic_sds_stp_request *sci_req = (struct scic_sds_stp_request *)request;
status = scic_sds_unsolicited_frame_control_get_header(
- &(this_request->parent.owning_controller->uf_control),
+ &(sci_req->parent.owning_controller->uf_control),
frame_index,
(void **)&frame_header
);
switch (frame_header->fis_type) {
case SATA_FIS_TYPE_REGD2H:
scic_sds_unsolicited_frame_control_get_buffer(
- &(this_request->parent.owning_controller->uf_control),
+ &(sci_req->parent.owning_controller->uf_control),
frame_index,
(void **)&frame_buffer
);
scic_sds_controller_copy_sata_response(
- &this_request->d2h_reg_fis, (u32 *)frame_header, frame_buffer
+ &sci_req->d2h_reg_fis, (u32 *)frame_header, frame_buffer
);
/* The command has completed with error */
scic_sds_request_set_status(
- &this_request->parent,
+ &sci_req->parent,
SCU_TASK_DONE_CHECK_RESPONSE,
SCI_FAILURE_IO_RESPONSE_VALID
);
"%s: IO Request:0x%p Frame Id:%d protocol "
"violation occurred\n",
__func__,
- this_request,
+ sci_req,
frame_index);
scic_sds_request_set_status(
- &this_request->parent,
+ &sci_req->parent,
SCU_TASK_DONE_UNEXP_FIS,
SCI_FAILURE_PROTOCOL_VIOLATION
);
}
sci_base_state_machine_change_state(
- &this_request->parent.state_machine,
+ &sci_req->parent.state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED);
/* Frame has been decoded return it to the controller */
scic_sds_controller_release_frame(
- this_request->parent.owning_controller, frame_index
+ sci_req->parent.owning_controller, frame_index
);
} else
dev_err(scic_to_dev(request->owning_controller),
"%s: SCIC IO Request 0x%p could not get frame header "
"for frame index %d, status %x\n",
- __func__, this_request, frame_index, status);
+ __func__, sci_req, frame_index, status);
return status;
}
static void scic_sds_stp_request_started_soft_reset_await_h2d_asserted_completion_enter(
struct sci_base_object *object)
{
- struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+ struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
SET_STATE_HANDLER(
- this_request,
+ sci_req,
scic_sds_stp_request_started_soft_reset_substate_handler_table,
SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_ASSERTED_COMPLETION_SUBSTATE
);
scic_sds_remote_device_set_working_request(
- this_request->target_device, this_request
+ sci_req->target_device, sci_req
);
}
static void scic_sds_stp_request_started_soft_reset_await_h2d_diagnostic_completion_enter(
struct sci_base_object *object)
{
- struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+ struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
struct scu_task_context *task_context;
struct sata_fis_reg_h2d *h2d_fis;
enum sci_status status;
/* Clear the SRST bit */
- h2d_fis = scic_stp_io_request_get_h2d_reg_address(this_request);
+ h2d_fis = scic_stp_io_request_get_h2d_reg_address(sci_req);
h2d_fis->control = 0;
/* Clear the TC control bit */
task_context = scic_sds_controller_get_task_context_buffer(
- this_request->owning_controller, this_request->io_tag);
+ sci_req->owning_controller, sci_req->io_tag);
task_context->control_frame = 0;
- status = scic_controller_continue_io(this_request);
+ status = scic_controller_continue_io(sci_req);
if (status == SCI_SUCCESS) {
SET_STATE_HANDLER(
- this_request,
+ sci_req,
scic_sds_stp_request_started_soft_reset_substate_handler_table,
SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_DIAGNOSTIC_COMPLETION_SUBSTATE
);
static void scic_sds_stp_request_started_soft_reset_await_d2h_response_enter(
struct sci_base_object *object)
{
- struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+ struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
SET_STATE_HANDLER(
- this_request,
+ sci_req,
scic_sds_stp_request_started_soft_reset_substate_handler_table,
SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_D2H_RESPONSE_FRAME_SUBSTATE
);
bool copy_rx_frame);
enum sci_status scic_sds_stp_udma_request_construct(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
u32 transfer_length,
enum dma_data_direction dir);
enum sci_status scic_sds_stp_non_data_request_construct(
- struct scic_sds_request *this_request);
+ struct scic_sds_request *sci_req);
enum sci_status scic_sds_stp_soft_reset_request_construct(
- struct scic_sds_request *this_request);
+ struct scic_sds_request *sci_req);
enum sci_status scic_sds_stp_ncq_request_construct(
- struct scic_sds_request *this_request,
+ struct scic_sds_request *sci_req,
u32 transfer_length,
enum dma_data_direction dir);
git.openpandora.org / pandora-kernel.git / commitdiff