hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Staging: unisys: channels: Cleanup sparse warnings 

Clean up multiple sparse warnings mostly due to different address spaces
when accessing I/O memory.

Also, remove SignalRemoveAll(), SignalQueueHasOneElement(),
SignalQueueIsFull(), because they were never called.

Signed-off-by: Ken Cox <jkc@redhat.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Ken Cox 2014-03-13 15:39:18 -05:00 committed by Greg Kroah-Hartman
parent 4b4b535e64
commit a1d842e84f
4 changed files with 49 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

166
drivers/staging/unisys/channels/channel.c
View File

@ -44,38 +44,41 @@
* 1 if the insertion succeeds, 0 if the queue was full.
*/
unsigned char
visor_signal_insert(pCHANNEL_HEADER pChannel, U32 Queue, void *pSignal)
visor_signal_insert(CHANNEL_HEADER __iomem *pChannel, U32 Queue, void *pSignal)
{
void *psignal;
unsigned int head, tail;
pSIGNAL_QUEUE_HEADER pqhdr =
(pSIGNAL_QUEUE_HEADER) ((char *) pChannel +
pChannel->oChannelSpace) + Queue;
void __iomem *psignal;
unsigned int head, tail, nof;
SIGNAL_QUEUE_HEADER __iomem *pqhdr =
(SIGNAL_QUEUE_HEADER __iomem *)
((char __iomem *) pChannel + readq(&pChannel->oChannelSpace))
+ Queue;
/* capture current head and tail */
head = pqhdr->Head;
tail = pqhdr->Tail;
head = readl(&pqhdr->Head);
tail = readl(&pqhdr->Tail);
/* queue is full if (head + 1) % n equals tail */
if (((head + 1) % pqhdr->MaxSignalSlots) == tail) {
pqhdr->NumOverflows++;
if (((head + 1) % readl(&pqhdr->MaxSignalSlots)) == tail) {
nof = readq(&pqhdr->NumOverflows) + 1;
writeq(nof, &pqhdr->NumOverflows);
return 0;
}
/* increment the head index */
head = (head + 1) % pqhdr->MaxSignalSlots;
head = (head + 1) % readl(&pqhdr->MaxSignalSlots);
/* copy signal to the head location from the area pointed to
* by pSignal
*/
psignal =
(char *) pqhdr + pqhdr->oSignalBase + (head * pqhdr->SignalSize);
MEMCPY(psignal, pSignal, pqhdr->SignalSize);
psignal = (char __iomem *)pqhdr + readq(&pqhdr->oSignalBase) +
(head * readl(&pqhdr->SignalSize));
MEMCPY_TOIO(psignal, pSignal, readl(&pqhdr->SignalSize));
VolatileBarrier();
pqhdr->Head = head;
writel(head, &pqhdr->Head);
pqhdr->NumSignalsSent++;
writeq(readq(&pqhdr->NumSignalsSent) + 1, &pqhdr->NumSignalsSent);
return 1;
}
EXPORT_SYMBOL_GPL(visor_signal_insert);
@ -99,36 +102,37 @@ EXPORT_SYMBOL_GPL(visor_signal_insert);
* 1 if the removal succeeds, 0 if the queue was empty.
*/
unsigned char
visor_signal_remove(pCHANNEL_HEADER pChannel, U32 Queue, void *pSignal)
visor_signal_remove(CHANNEL_HEADER __iomem *pChannel, U32 Queue, void *pSignal)
{
void *psource;
void __iomem *psource;
unsigned int head, tail;
pSIGNAL_QUEUE_HEADER pqhdr =
(pSIGNAL_QUEUE_HEADER) ((char *) pChannel +
pChannel->oChannelSpace) + Queue;
SIGNAL_QUEUE_HEADER __iomem *pqhdr =
(SIGNAL_QUEUE_HEADER __iomem *) ((char __iomem *) pChannel +
readq(&pChannel->oChannelSpace)) + Queue;
/* capture current head and tail */
head = pqhdr->Head;
tail = pqhdr->Tail;
head = readl(&pqhdr->Head);
tail = readl(&pqhdr->Tail);
/* queue is empty if the head index equals the tail index */
if (head == tail) {
pqhdr->NumEmptyCnt++;
writeq(readq(&pqhdr->NumEmptyCnt) + 1, &pqhdr->NumEmptyCnt);
return 0;
}
/* advance past the 'empty' front slot */
tail = (tail + 1) % pqhdr->MaxSignalSlots;
tail = (tail + 1) % readl(&pqhdr->MaxSignalSlots);
/* copy signal from tail location to the area pointed to by pSignal */
psource =
(char *) pqhdr + pqhdr->oSignalBase + (tail * pqhdr->SignalSize);
MEMCPY(pSignal, psource, pqhdr->SignalSize);
psource = (char __iomem *) pqhdr + readq(&pqhdr->oSignalBase) +
(tail * readl(&pqhdr->SignalSize));
MEMCPY_FROMIO(pSignal, psource, readl(&pqhdr->SignalSize));
VolatileBarrier();
pqhdr->Tail = tail;
writel(tail, &pqhdr->Tail);
pqhdr->NumSignalsReceived++;
writeq(readq(&pqhdr->NumSignalsReceived) + 1,
&pqhdr->NumSignalsReceived);
return 1;
}
EXPORT_SYMBOL_GPL(visor_signal_remove);
@ -192,59 +196,6 @@ SignalRemoveAll(pCHANNEL_HEADER pChannel, U32 Queue, void *pSignal)
return signalCount;
}
/*
* Routine Description:
* Copies one signal from channel pChannel's nth Queue at the given position
* at the time of the call into the memory pointed to by pSignal.
*
* Parameters:
* pChannel: (IN) points to the IO Channel
* Queue: (IN) nth Queue of the IO Channel
* Position: (IN) nth entry in Queue of the IO Channel
* pSignal: (IN) pointer to where the signals are to be copied
*
* Assumptions:
* - pChannel and Queue are valid.
* - pSignal points to a memory area large enough to hold queue's SignalSize
*
* Return value:
* 1 if the copy succeeds, 0 if the queue was empty or Position was invalid.
*/
unsigned char
SignalPeek(pCHANNEL_HEADER pChannel, U32 Queue, U32 Position, void *pSignal)
{
void *psignal;
unsigned int head, tail;
pSIGNAL_QUEUE_HEADER pqhdr =
(pSIGNAL_QUEUE_HEADER) ((char *) pChannel +
pChannel->oChannelSpace) + Queue;
head = pqhdr->Head;
tail = pqhdr->Tail;
/* check if Position is out of range or queue is empty */
if (Position >= pqhdr->MaxSignalSlots || Position == tail
|| head == tail)
return 0;
/* check if Position is between tail and head */
if (head > tail) {
if (Position > head || Position < tail)
return 0;
} else if ((Position > head) && (Position < tail))
return 0;
/* copy signal from Position location to the area pointed to
* by pSignal
*/
psignal =
(char *) pqhdr + pqhdr->oSignalBase +
(Position * pqhdr->SignalSize);
MEMCPY(pSignal, psignal, pqhdr->SignalSize);
return 1;
}
/*
* Routine Description:
* Determine whether a signal queue is empty.
@ -257,51 +208,12 @@ SignalPeek(pCHANNEL_HEADER pChannel, U32 Queue, U32 Position, void *pSignal)
* 1 if the signal queue is empty, 0 otherwise.
*/
unsigned char
visor_signalqueue_empty(pCHANNEL_HEADER pChannel, U32 Queue)
visor_signalqueue_empty(CHANNEL_HEADER __iomem *pChannel, U32 Queue)
{
pSIGNAL_QUEUE_HEADER pqhdr =
(pSIGNAL_QUEUE_HEADER) ((char *) pChannel +
pChannel->oChannelSpace) + Queue;
return pqhdr->Head == pqhdr->Tail;
SIGNAL_QUEUE_HEADER __iomem *pqhdr =
(SIGNAL_QUEUE_HEADER __iomem *) ((char __iomem *) pChannel +
readq(&pChannel->oChannelSpace)) + Queue;
return readl(&pqhdr->Head) == readl(&pqhdr->Tail);
}
EXPORT_SYMBOL_GPL(visor_signalqueue_empty);
/*
* Routine Description:
* Determine whether a signal queue is empty.
*
* Parameters:
* pChannel: (IN) points to the IO Channel
* Queue: (IN) nth Queue of the IO Channel
*
* Return value:
* 1 if the signal queue has 1 element, 0 otherwise.
*/
unsigned char
SignalQueueHasOneElement(pCHANNEL_HEADER pChannel, U32 Queue)
{
pSIGNAL_QUEUE_HEADER pqhdr =
(pSIGNAL_QUEUE_HEADER) ((char *) pChannel +
pChannel->oChannelSpace) + Queue;
return ((pqhdr->Tail + 1) % pqhdr->MaxSignalSlots) == pqhdr->Head;
}
/*
* Routine Description:
* Determine whether a signal queue is full.
*
* Parameters:
* pChannel: (IN) points to the IO Channel
* Queue: (IN) nth Queue of the IO Channel
*
* Return value:
* 1 if the signal queue is full, 0 otherwise.
*/
unsigned char
SignalQueueIsFull(pCHANNEL_HEADER pChannel, U32 Queue)
{
pSIGNAL_QUEUE_HEADER pqhdr =
(pSIGNAL_QUEUE_HEADER) ((char *) pChannel +
pChannel->oChannelSpace) + Queue;
return ((pqhdr->Head + 1) % pqhdr->MaxSignalSlots) == pqhdr->Tail;
}

8
drivers/staging/unisys/channels/chanstub.c
View File

@ -27,19 +27,19 @@
#include "chanstub.h"
#include "version.h"
__init int
static __init int
channel_mod_init(void)
{
return 0;
}
__exit void
static __exit void
channel_mod_exit(void)
{
}
unsigned char
SignalInsert_withLock(pCHANNEL_HEADER pChannel, U32 Queue,
SignalInsert_withLock(CHANNEL_HEADER __iomem *pChannel, U32 Queue,
void *pSignal, spinlock_t *lock)
{
unsigned char result;
@ -51,7 +51,7 @@ SignalInsert_withLock(pCHANNEL_HEADER pChannel, U32 Queue,
}
unsigned char
SignalRemove_withLock(pCHANNEL_HEADER pChannel, U32 Queue,
SignalRemove_withLock(CHANNEL_HEADER __iomem *pChannel, U32 Queue,
void *pSignal, spinlock_t *lock)
{
unsigned char result;

4
drivers/staging/unisys/channels/chanstub.h
View File

@ -15,9 +15,9 @@
#ifndef __CHANSTUB_H__
#define __CHANSTUB_H__
unsigned char SignalInsert_withLock(pCHANNEL_HEADER pChannel, U32 Queue,
unsigned char SignalInsert_withLock(CHANNEL_HEADER __iomem *pChannel, U32 Queue,
void *pSignal, spinlock_t *lock);
unsigned char SignalRemove_withLock(pCHANNEL_HEADER pChannel, U32 Queue,
unsigned char SignalRemove_withLock(CHANNEL_HEADER __iomem *pChannel, U32 Queue,
void *pSignal, spinlock_t *lock);
#endif

4
drivers/staging/unisys/include/commontypes.h
View File

@ -23,6 +23,7 @@
#ifdef __KERNEL__
#include <linux/types.h>
#include <linux/version.h>
#include <linux/io.h>
#else
#include <stdint.h>
#include <syslog.h>
@ -72,6 +73,7 @@ typedef U64 GUEST_PHYSICAL_ADDRESS;
#define MEMSET(ptr, val, len) memset(ptr, val, len)
#define MEMCMP(m1, m2, len) memcmp(m1, m2, len)
#define MEMCMP_IO(m1, m2, len) memcmp((void __force *)m1, m2, len)
#define STRLEN(s) ((UINTN)strlen((const char *)s))
#define STRCPY(d, s) (strcpy((char *)d, (const char *)s))
@ -81,6 +83,8 @@ typedef U64 GUEST_PHYSICAL_ADDRESS;
#ifdef __KERNEL__
#define MEMORYBARRIER mb()
#define MEMCPY(dest, src, len) memcpy(dest, src, len)
#define MEMCPY_TOIO(dest, src, len) memcpy_toio(dest, src, len)
#define MEMCPY_FROMIO(dest, src, len) memcpy_fromio(dest, src, len)
#define CHANNEL_GUID_MISMATCH(chType, chName, field, expected, actual, fil, \
lin, logCtx) \