shinys000114/linux
1
0
Fork 0
mirror of https://github.com/hardkernel/linux.git synced 2026-06-04 10:12:16 +09:00
Code Issues Packages Projects Releases Wiki Activity

staging: unisys: refactor ULTRA_IO_CHANNEL_PROTOCOL

Browse Source 
Remove the typedef from ULTRA_IO_CHANNEL_PROTOCOL and use the name struct
spar_io_channel_protocol instead. Fix CamelCase member names:

ChannelHeader => channel_header
cmdQ => cmd_q
rspQ => rsp_q
zoneGuid => zone_uuid
ClientString => client_string

Update all references to changed names.

Signed-off-by: Benjamin Romer <benjamin.romer@unisys.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Benjamin Romer
2014-10-23 14:31:04 -04:00
committed by Greg Kroah-Hartman
parent be3c366905
commit bedc756e3a
3 changed files with 79 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

127
drivers/staging/unisys/common-spar/include/channels/iochannel.h
View File

@@ -662,11 +662,11 @@ struct uiscmdrsp {
/* This is just the header of the IO channel. It is assumed that directly after
* this header there is a large region of memory which contains the command and
* response queues as specified in cmdQ and rspQ SIGNAL_QUEUE_HEADERS. */
typedef struct _ULTRA_IO_CHANNEL_PROTOCOL {
struct channel_header ChannelHeader;
struct signal_queue_header cmdQ;
struct signal_queue_header rspQ;
* response queues as specified in cmd_q and rsp_q SIGNAL_QUEUE_HEADERS. */
struct spar_io_channel_protocol {
struct channel_header channel_header;
struct signal_queue_header cmd_q;
struct signal_queue_header rsp_q;
union {
struct {
struct vhba_wwnn wwnn; /* 8 bytes */
@@ -676,14 +676,14 @@ typedef struct _ULTRA_IO_CHANNEL_PROTOCOL {
u8 macaddr[MAX_MACADDR_LEN]; /* 6 bytes */
u32 num_rcv_bufs; /* 4 */
u32 mtu; /* 4 */
uuid_le zoneGuid; /* 16 */
uuid_le zone_uuid; /* 16 */
} vnic; /* total 30 */
};
#define MAX_CLIENTSTRING_LEN 1024
u8 clientString[MAX_CLIENTSTRING_LEN]; /* NULL terminated - so holds
u8 client_string[MAX_CLIENTSTRING_LEN];/* NULL terminated - so holds
* max - 1 bytes */
} ULTRA_IO_CHANNEL_PROTOCOL;
};
#pragma pack(pop)
/* ///////////// END PRAGMA PACK PUSH 1 /////////////////////////// */
@@ -712,13 +712,14 @@ typedef struct _ULTRA_IO_CHANNEL_PROTOCOL {
* INLINE functions for initializing and accessing I/O data channels
*/
#define NUMSIGNALS(x, q) (((ULTRA_IO_CHANNEL_PROTOCOL *)(x))->q.MaxSignalSlots)
#define SIZEOF_PROTOCOL (COVER(sizeof(ULTRA_IO_CHANNEL_PROTOCOL), 64))
#define NUMSIGNALS(x, q) \
(((struct spar_io_channel_protocol *)(x))->q.MaxSignalSlots)
#define SIZEOF_PROTOCOL (COVER(sizeof(struct spar_io_channel_protocol), 64))
#define SIZEOF_CMDRSP (COVER(sizeof(struct uiscmdrsp), 64))
#define IO_CHANNEL_SIZE(x) COVER(SIZEOF_PROTOCOL + \
(NUMSIGNALS(x, cmdQ) + \
NUMSIGNALS(x, rspQ)) * SIZEOF_CMDRSP, 4096)
(NUMSIGNALS(x, cmd_q) + \
NUMSIGNALS(x, rsp_q)) * SIZEOF_CMDRSP, 4096)
#define MIN_IO_CHANNEL_SIZE COVER(SIZEOF_PROTOCOL + \
2 * MIN_NUMSIGNALS * SIZEOF_CMDRSP, 4096)
#ifdef __GNUC__
@@ -728,34 +729,34 @@ typedef struct _ULTRA_IO_CHANNEL_PROTOCOL {
#define QSIZEFROMBYTES(bytes) (QSLOTSFROMBYTES(bytes)*SIZEOF_CMDRSP)
#define SignalQInit(x) \
do { \
x->cmdQ.size = QSIZEFROMBYTES(x->ChannelHeader.size); \
x->cmdQ.sig_base_offset = SIZEOF_PROTOCOL - \
offsetof(ULTRA_IO_CHANNEL_PROTOCOL, cmdQ); \
x->cmdQ.signal_size = SIZEOF_CMDRSP; \
x->cmdQ.max_slots = \
QSLOTSFROMBYTES(x->ChannelHeader.size); \
x->cmdQ.max_signals = x->cmdQ.max_slots - 1; \
x->rspQ.size = QSIZEFROMBYTES(x->ChannelHeader.size); \
x->rspQ.sig_base_offset = \
(SIZEOF_PROTOCOL + x->cmdQ.size) - \
offsetof(ULTRA_IO_CHANNEL_PROTOCOL, rspQ); \
x->rspQ.signal_size = SIZEOF_CMDRSP; \
x->rspQ.max_slots = \
QSLOTSFROMBYTES(x->ChannelHeader.size); \
x->rspQ.max_signals = x->rspQ.max_slots - 1; \
x->ChannelHeader.ch_space_offset = \
offsetof(ULTRA_IO_CHANNEL_PROTOCOL, cmdQ); \
x->cmd_q.size = QSIZEFROMBYTES(x->channel_header.size); \
x->cmd_q.sig_base_offset = SIZEOF_PROTOCOL - \
offsetof(struct spar_io_channel_protocol, cmd_q);\
x->cmd_q.signal_size = SIZEOF_CMDRSP; \
x->cmd_q.max_slots = \
QSLOTSFROMBYTES(x->channel_header.size); \
x->cmd_q.max_signals = x->cmd_q.max_slots - 1; \
x->rsp_q.size = QSIZEFROMBYTES(x->channel_header.size); \
x->rsp_q.sig_base_offset = \
(SIZEOF_PROTOCOL + x->cmd_q.size) - \
offsetof(struct spar_io_channel_protocol, rsp_q);\
x->rsp_q.signal_size = SIZEOF_CMDRSP; \
x->rsp_q.max_slots = \
QSLOTSFROMBYTES(x->channel_header.size); \
x->rsp_q.max_signals = x->rsp_q.max_slots - 1; \
x->channel_header.ch_space_offset = \
offsetof(struct spar_io_channel_protocol, cmd_q);\
} while (0)
#define INIT_CLIENTSTRING(chan, type, clientStr, clientStrLen) \
do { \
if (clientStr) { \
chan->ChannelHeader.cli_str_offset = \
offsetof(type, clientString); \
memcpy(chan->clientString, clientStr, \
chan->channel_header.cli_str_offset = \
offsetof(type, client_string); \
memcpy(chan->client_string, clientStr, \
MINNUM(clientStrLen, \
(u32)(MAX_CLIENTSTRING_LEN - 1))); \
chan->clientString[MINNUM(clientStrLen, \
chan->client_string[MINNUM(clientStrLen, \
(u32)(MAX_CLIENTSTRING_LEN \
- 1))] \
= '\0'; \
@@ -773,68 +774,68 @@ typedef struct _ULTRA_IO_CHANNEL_PROTOCOL {
ULTRA_CHANNEL_SERVER_TRANSITION(x, chanId, SrvState, \
CHANNELSRV_UNINITIALIZED, logCtx)
static inline int ULTRA_VHBA_init_channel(ULTRA_IO_CHANNEL_PROTOCOL *x,
static inline int ULTRA_VHBA_init_channel(struct spar_io_channel_protocol *x,
struct vhba_wwnn *wwnn,
struct vhba_config_max *max,
unsigned char *clientStr,
u32 clientStrLen, u64 bytes) {
memset(x, 0, sizeof(ULTRA_IO_CHANNEL_PROTOCOL));
x->ChannelHeader.version_id = ULTRA_VHBA_CHANNEL_PROTOCOL_VERSIONID;
x->ChannelHeader.signature = ULTRA_VHBA_CHANNEL_PROTOCOL_SIGNATURE;
x->ChannelHeader.srv_state = CHANNELSRV_UNINITIALIZED;
x->ChannelHeader.header_size = sizeof(x->ChannelHeader);
x->ChannelHeader.size = COVER(bytes, 4096);
x->ChannelHeader.chtype = spar_vhba_channel_protocol_uuid;
x->ChannelHeader.zone_uuid = NULL_UUID_LE;
memset(x, 0, sizeof(struct spar_io_channel_protocol));
x->channel_header.version_id = ULTRA_VHBA_CHANNEL_PROTOCOL_VERSIONID;
x->channel_header.signature = ULTRA_VHBA_CHANNEL_PROTOCOL_SIGNATURE;
x->channel_header.srv_state = CHANNELSRV_UNINITIALIZED;
x->channel_header.header_size = sizeof(x->channel_header);
x->channel_header.size = COVER(bytes, 4096);
x->channel_header.chtype = spar_vhba_channel_protocol_uuid;
x->channel_header.zone_uuid = NULL_UUID_LE;
x->vhba.wwnn = *wwnn;
x->vhba.max = *max;
INIT_CLIENTSTRING(x, ULTRA_IO_CHANNEL_PROTOCOL, clientStr,
INIT_CLIENTSTRING(x, struct spar_io_channel_protocol, clientStr,
clientStrLen);
SignalQInit(x);
if ((x->cmdQ.max_slots > MAX_NUMSIGNALS) ||
(x->rspQ.max_slots > MAX_NUMSIGNALS)) {
if ((x->cmd_q.max_slots > MAX_NUMSIGNALS) ||
(x->rsp_q.max_slots > MAX_NUMSIGNALS)) {
return 0;
}
if ((x->cmdQ.max_slots < MIN_NUMSIGNALS) ||
(x->rspQ.max_slots < MIN_NUMSIGNALS)) {
if ((x->cmd_q.max_slots < MIN_NUMSIGNALS) ||
(x->rsp_q.max_slots < MIN_NUMSIGNALS)) {
return 0;
}
return 1;
}
static inline void ULTRA_VHBA_set_max(ULTRA_IO_CHANNEL_PROTOCOL *x,
static inline void ULTRA_VHBA_set_max(struct spar_io_channel_protocol *x,
struct vhba_config_max *max) {
x->vhba.max = *max;
}
static inline int ULTRA_VNIC_init_channel(ULTRA_IO_CHANNEL_PROTOCOL *x,
static inline int ULTRA_VNIC_init_channel(struct spar_io_channel_protocol *x,
unsigned char *macaddr,
u32 num_rcv_bufs, u32 mtu,
uuid_le zoneGuid,
unsigned char *clientStr,
u32 clientStrLen,
u64 bytes) {
memset(x, 0, sizeof(ULTRA_IO_CHANNEL_PROTOCOL));
x->ChannelHeader.version_id = ULTRA_VNIC_CHANNEL_PROTOCOL_VERSIONID;
x->ChannelHeader.signature = ULTRA_VNIC_CHANNEL_PROTOCOL_SIGNATURE;
x->ChannelHeader.srv_state = CHANNELSRV_UNINITIALIZED;
x->ChannelHeader.header_size = sizeof(x->ChannelHeader);
x->ChannelHeader.size = COVER(bytes, 4096);
x->ChannelHeader.chtype = spar_vnic_channel_protocol_uuid;
x->ChannelHeader.zone_uuid = NULL_UUID_LE;
memset(x, 0, sizeof(struct spar_io_channel_protocol));
x->channel_header.version_id = ULTRA_VNIC_CHANNEL_PROTOCOL_VERSIONID;
x->channel_header.signature = ULTRA_VNIC_CHANNEL_PROTOCOL_SIGNATURE;
x->channel_header.srv_state = CHANNELSRV_UNINITIALIZED;
x->channel_header.header_size = sizeof(x->channel_header);
x->channel_header.size = COVER(bytes, 4096);
x->channel_header.chtype = spar_vnic_channel_protocol_uuid;
x->channel_header.zone_uuid = NULL_UUID_LE;
memcpy(x->vnic.macaddr, macaddr, MAX_MACADDR_LEN);
x->vnic.num_rcv_bufs = num_rcv_bufs;
x->vnic.mtu = mtu;
x->vnic.zoneGuid = zoneGuid;
INIT_CLIENTSTRING(x, ULTRA_IO_CHANNEL_PROTOCOL, clientStr,
x->vnic.zone_uuid = zoneGuid;
INIT_CLIENTSTRING(x, struct spar_io_channel_protocol, clientStr,
clientStrLen);
SignalQInit(x);
if ((x->cmdQ.max_slots > MAX_NUMSIGNALS) ||
(x->rspQ.max_slots > MAX_NUMSIGNALS)) {
if ((x->cmd_q.max_slots > MAX_NUMSIGNALS) ||
(x->rsp_q.max_slots > MAX_NUMSIGNALS)) {
return 0;
}
if ((x->cmdQ.max_slots < MIN_NUMSIGNALS) ||
(x->rspQ.max_slots < MIN_NUMSIGNALS)) {
if ((x->cmd_q.max_slots < MIN_NUMSIGNALS) ||
(x->rsp_q.max_slots < MIN_NUMSIGNALS)) {
return 0;
}
return 1;

4
drivers/staging/unisys/uislib/uislib.c
View File

@@ -1568,8 +1568,8 @@ uislib_mod_init(void)
(ulong) sizeof(struct spar_controlvm_channel_protocol));
LOGINF("sizeof(CHANNEL_HEADER):%lu bytes\n",
(ulong) sizeof(struct channel_header));
LOGINF("sizeof(ULTRA_IO_CHANNEL_PROTOCOL):%lu bytes\n",
(ulong) sizeof(ULTRA_IO_CHANNEL_PROTOCOL));
LOGINF("sizeof(struct spar_io_channel_protocol):%lu bytes\n",
(ulong) sizeof(struct spar_io_channel_protocol));
LOGINF("SIZEOF_CMDRSP:%lu bytes\n", SIZEOF_CMDRSP);
LOGINF("SIZEOF_PROTOCOL:%lu bytes\n", SIZEOF_PROTOCOL);

26
drivers/staging/unisys/virtpci/virtpci.c
View File

@@ -171,13 +171,13 @@ struct virtpci_busdev {
/*****************************************************/
static inline
int WAIT_FOR_IO_CHANNEL(ULTRA_IO_CHANNEL_PROTOCOL __iomem *chanptr)
int WAIT_FOR_IO_CHANNEL(struct spar_io_channel_protocol __iomem *chanptr)
{
int count = 120;
while (count > 0) {
if (SPAR_CHANNEL_SERVER_READY(&chanptr->ChannelHeader))
if (SPAR_CHANNEL_SERVER_READY(&chanptr->channel_header))
return 1;
UIS_THREAD_WAIT_SEC(1);
count--;
@@ -293,11 +293,11 @@ static int add_vbus(struct add_vbus_guestpart *addparams)
*/
#define GET_SCSIADAPINFO_FROM_CHANPTR(chanptr) { \
memcpy_fromio(&scsi.wwnn, \
&((ULTRA_IO_CHANNEL_PROTOCOL __iomem *) \
&((struct spar_io_channel_protocol __iomem *) \
chanptr)->vhba.wwnn, \
sizeof(struct vhba_wwnn)); \
memcpy_fromio(&scsi.max, \
&((ULTRA_IO_CHANNEL_PROTOCOL __iomem *) \
&((struct spar_io_channel_protocol __iomem *) \
chanptr)->vhba.max, \
sizeof(struct vhba_config_max)); \
}
@@ -325,7 +325,7 @@ static int add_vhba(struct add_virt_guestpart *addparams)
POSTCODE_LINUX_2(VPCI_CREATE_ENTRY_PC, POSTCODE_SEVERITY_INFO);
if (!WAIT_FOR_IO_CHANNEL
((ULTRA_IO_CHANNEL_PROTOCOL __iomem *) addparams->chanptr)) {
((struct spar_io_channel_protocol __iomem *) addparams->chanptr)) {
LOGERR("Timed out. Channel not ready\n");
POSTCODE_LINUX_2(VPCI_CREATE_FAILURE_PC, POSTCODE_SEVERITY_ERR);
return 0;
@@ -355,17 +355,17 @@ static int add_vhba(struct add_virt_guestpart *addparams)
*/
#define GET_NETADAPINFO_FROM_CHANPTR(chanptr) { \
memcpy_fromio(net.mac_addr, \
((ULTRA_IO_CHANNEL_PROTOCOL __iomem *) \
((struct spar_io_channel_protocol __iomem *) \
chanptr)->vnic.macaddr, \
MAX_MACADDR_LEN); \
net.num_rcv_bufs = \
readl(&((ULTRA_IO_CHANNEL_PROTOCOL __iomem *) \
readl(&((struct spar_io_channel_protocol __iomem *)\
chanptr)->vnic.num_rcv_bufs); \
net.mtu = readl(&((ULTRA_IO_CHANNEL_PROTOCOL __iomem *) \
net.mtu = readl(&((struct spar_io_channel_protocol __iomem *) \
chanptr)->vnic.mtu); \
memcpy_fromio(&net.zoneGuid, \
&((ULTRA_IO_CHANNEL_PROTOCOL __iomem *) \
chanptr)->vnic.zoneGuid, \
&((struct spar_io_channel_protocol __iomem *)\
chanptr)->vnic.zone_uuid, \
sizeof(uuid_le)); \
}
@@ -382,7 +382,7 @@ add_vnic(struct add_virt_guestpart *addparams)
POSTCODE_LINUX_2(VPCI_CREATE_ENTRY_PC, POSTCODE_SEVERITY_INFO);
if (!WAIT_FOR_IO_CHANNEL
((ULTRA_IO_CHANNEL_PROTOCOL __iomem *) addparams->chanptr)) {
((struct spar_io_channel_protocol __iomem *) addparams->chanptr)) {
LOGERR("Timed out, channel not ready\n");
POSTCODE_LINUX_2(VPCI_CREATE_FAILURE_PC, POSTCODE_SEVERITY_ERR);
return 0;
@@ -905,7 +905,7 @@ static int virtpci_device_add(struct device *parentbus, int devtype,
struct virtpci_dev *tmpvpcidev = NULL, *prev;
unsigned long flags;
int ret;
ULTRA_IO_CHANNEL_PROTOCOL __iomem *pIoChan = NULL;
struct spar_io_channel_protocol __iomem *pIoChan = NULL;
struct device *pDev;
LOGINF("virtpci_device_add parentbus:%p chanptr:%p\n", parentbus,
@@ -946,7 +946,7 @@ static int virtpci_device_add(struct device *parentbus, int devtype,
virtpcidev->queueinfo.send_int_if_needed = NULL;
/* Set up safe queue... */
pIoChan = (ULTRA_IO_CHANNEL_PROTOCOL __iomem *)
pIoChan = (struct spar_io_channel_protocol __iomem *)
virtpcidev->queueinfo.chan;
virtpcidev->intr = addparams->intr;