};
-/**
- * scic_remote_device_get_object_size() - This method simply returns the
- * maximum memory space needed to store a remote device object.
- *
- * a positive integer value indicating the size (in bytes) of the remote device
- * object.
- */
-u32 scic_remote_device_get_object_size(
- void);
-
-struct scic_sds_port;
-struct scic_sds_remote_device;
/**
* scic_remote_device_construct() - This method will perform the construction
* common to all remote device objects.
#define SCIC_SDS_REMOTE_DEVICE_RESET_TIMEOUT (1000)
-/*
- * *****************************************************************************
- * * CORE REMOTE DEVICE PRIVATE METHODS
- * ***************************************************************************** */
-
-/*
- * *****************************************************************************
- * * CORE REMOTE DEVICE PUBLIC METHODS
- * ***************************************************************************** */
-
-u32 scic_remote_device_get_object_size(void)
-{
- return sizeof (struct scic_sds_remote_device);
-}
-
enum sci_status scic_remote_device_da_construct(
struct scic_sds_remote_device *sci_dev)
{
isci_phy_init(&isci_host->phys[i], isci_host, i);
for (i = 0; i < SCI_MAX_REMOTE_DEVICES; i++) {
- struct isci_remote_device *idev = idev_by_id(isci_host, i);
+ struct isci_remote_device *idev = &isci_host->devices[i];
INIT_LIST_HEAD(&idev->reqs_in_process);
INIT_LIST_HEAD(&idev->node);
struct list_head requests_to_errorback;
spinlock_t scic_lock;
- /* careful only access this via idev_by_id */
- struct isci_remote_device devices[0];
+ struct isci_remote_device devices[SCI_MAX_REMOTE_DEVICES];
};
-static inline struct isci_remote_device *idev_by_id(struct isci_host *ihost, int i)
-{
- void *p = ihost->devices;
-
- return p + i * (sizeof(struct isci_remote_device) +
- scic_remote_device_get_object_size());
-}
-
/**
* struct isci_pci_info - This class represents the pci function containing the
* controllers. Depending on PCI SKU, there could be up to 2 controllers in
struct Scsi_Host *shost;
int err;
- isci_host = devm_kzalloc(&pdev->dev, sizeof(*isci_host) +
- SCI_MAX_REMOTE_DEVICES *
- (sizeof(struct isci_remote_device) +
- scic_remote_device_get_object_size()), GFP_KERNEL);
+ isci_host = devm_kzalloc(&pdev->dev, sizeof(*isci_host), GFP_KERNEL);
if (!isci_host)
return NULL;
BUG();
}
- scic_remote_device_destruct(to_sci_dev(idev));
+ scic_remote_device_destruct(&idev->sci);
idev->domain_dev->lldd_dev = NULL;
idev->domain_dev = NULL;
idev->isci_port = NULL;
/* let the core do it's common constuction. */
scic_remote_device_construct(port->sci_port_handle,
- to_sci_dev(isci_device));
+ &isci_device->sci);
/* let the core do it's device specific constuction. */
if (isci_device->domain_dev->parent &&
"%s: parent->dev_type = EDGE_DEV\n",
__func__);
- status = scic_remote_device_ea_construct(to_sci_dev(isci_device),
+ status = scic_remote_device_ea_construct(&isci_device->sci,
(struct smp_response_discover *)&discover_response);
} else
- status = scic_remote_device_da_construct(to_sci_dev(isci_device));
+ status = scic_remote_device_da_construct(&isci_device->sci);
if (status != SCI_SUCCESS) {
return status;
}
- sci_object_set_association(to_sci_dev(isci_device), isci_device);
+ /* XXX will be killed with sci_base_object removal */
+ sci_object_set_association(&isci_device->sci, isci_device);
/* start the device. */
- status = scic_remote_device_start(to_sci_dev(isci_device),
+ status = scic_remote_device_start(&isci_device->sci,
ISCI_REMOTE_DEVICE_START_TIMEOUT);
if (status != SCI_SUCCESS) {
int i;
for (i = 0; i < SCI_MAX_REMOTE_DEVICES; i++) {
- idev = idev_by_id(ihost, i);
+ idev = &ihost->devices[i];
if (!test_and_set_bit(IDEV_ALLOCATED, &idev->flags))
break;
}
set_bit(IDEV_STOP_PENDING, &idev->flags);
spin_lock_irqsave(&ihost->scic_lock, flags);
- status = scic_remote_device_stop(to_sci_dev(idev), 50);
+ status = scic_remote_device_stop(&idev->sci, 50);
spin_unlock_irqrestore(&ihost->scic_lock, flags);
/* Wait for the stop complete callback. */
#if !defined(_ISCI_REMOTE_DEVICE_H_)
#define _ISCI_REMOTE_DEVICE_H_
+#include "scic_sds_remote_device.h"
struct isci_host;
-struct scic_sds_remote_device;
struct isci_remote_device {
enum isci_status status;
struct list_head node;
struct list_head reqs_in_process;
spinlock_t state_lock;
+ struct scic_sds_remote_device sci;
};
-static inline struct scic_sds_remote_device *to_sci_dev(struct isci_remote_device *idev)
-{
- /* core data is an opaque buffer at the end of the idev */
- return (struct scic_sds_remote_device *) &idev[1];
-}
-
#define ISCI_REMOTE_DEVICE_START_TIMEOUT 5000
void isci_remote_device_start_complete(struct isci_host *ihost,
struct smp_discover_response_protocols dev_protocols;
enum sci_status status = SCI_SUCCESS;
struct sas_task *task = isci_request_access_task(request);
- struct scic_sds_remote_device *sci_device = to_sci_dev(isci_device);
+ struct scic_sds_remote_device *sci_device = &isci_device->sci;
dev_dbg(&isci_host->pdev->dev,
"%s: isci_device = 0x%p; request = %p, "
unsigned long flags;
isci_device = task->dev->lldd_dev;
- sci_device = to_sci_dev(isci_device);
+ sci_device = &isci_device->sci;
/* do common allocation and init of request object. */
ret = isci_request_alloc_io(
);
/* complete the io request to the core. */
- scic_controller_complete_io(
- isci_host->core_controller,
- to_sci_dev(isci_device),
- request->sci_request_handle
- );
+ scic_controller_complete_io(isci_host->core_controller,
+ &isci_device->sci,
+ request->sci_request_handle);
/* NULL the request handle so it cannot be completed or
* terminated again, and to cause any calls into abort
* task to recognize the already completed case.
"%s: isci_tmf = %p\n", __func__, isci_tmf);
isci_device = isci_tmf->device;
- sci_device = to_sci_dev(isci_device);
+ sci_device = &isci_device->sci;
/* do common allocation and init of request object. */
status = isci_request_alloc_tmf(
/* Terminate the TMF transmit request. */
status = scic_controller_terminate_request(
request->isci_host->core_controller,
- to_sci_dev(request->isci_device),
+ &request->isci_device->sci,
request->sci_request_handle
);
"%s: isci_device = %p\n",
__func__, isci_device);
- sci_device = to_sci_dev(isci_device);
+ sci_device = &isci_device->sci;
/* Assign the pointer to the TMF's completion kernel wait structure. */
tmf->complete = &completion;
needs_cleanup_handling = true;
status = scic_controller_terminate_request(
isci_host->core_controller,
- to_sci_dev(isci_device),
- isci_request->sci_request_handle
- );
+ &isci_device->sci,
+ isci_request->sci_request_handle);
}
spin_unlock_irqrestore(&isci_host->scic_lock, flags);
scic_controller_complete_io(
isci_host->core_controller,
- to_sci_dev(isci_device),
- request->sci_request_handle
- );
+ &isci_device->sci,
+ request->sci_request_handle);
/* NULL the request handle to make sure it cannot be terminated
* or completed again.
*/
}
spin_lock_irqsave(&isci_host->scic_lock, flags);
- status = scic_remote_device_reset(to_sci_dev(isci_dev));
+ status = scic_remote_device_reset(&isci_dev->sci);
if (status != SCI_SUCCESS) {
spin_unlock_irqrestore(&isci_host->scic_lock, flags);
/* WHAT TO DO HERE IF sas_phy_reset FAILS? */
spin_lock_irqsave(&isci_host->scic_lock, flags);
- status = scic_remote_device_reset_complete(to_sci_dev(isci_dev));
+ status = scic_remote_device_reset_complete(&isci_dev->sci);
spin_unlock_irqrestore(&isci_host->scic_lock, flags);
if (status != SCI_SUCCESS) {
projects / ~emulex / infiniband.git / commitdiff